Class: Relaton::Render::Fields

Inherits:
Object
  • Object
show all
Defined in:
lib/relaton/render/fields/fields.rb

Instance Method Summary collapse

Constructor Details

#initialize(options) ⇒ Fields

Returns a new instance of Fields.



6
7
8
 
# File 'lib/relaton/render/fields/fields.rb', line 6

def initialize(options)
  @r = options[:renderer]
end

Instance Method Details

#compound_fields_format(hash) ⇒ Object 



10
11
12
13
14
15
16
 
# File 'lib/relaton/render/fields/fields.rb', line 10

def compound_fields_format(hash)
  name_fields_format(hash)
  role_fields_format(hash)
  date_fields_format(hash)
  edition_fields_format(hash)
  misc_fields_format(hash)
end

#date_fields_format(hash) ⇒ Object 



49
50
51
52
53
54
 
# File 'lib/relaton/render/fields/fields.rb', line 49

def date_fields_format(hash)
  [i(date date), i(date_updated date_updated),
   i(date_accessed date_accessed)].each do |k|
    hash[k[0]] = dateformat(hash[k[1]], hash)
  end
end

#date_range(hash) ⇒ Object 



177
178
179
180
181
182
 
# File 'lib/relaton/render/fields/fields.rb', line 177

def date_range(hash)
  if hash[:from]
    "#{hash[:from]}–#{hash[:to]}"
  else range(hash)
  end
end

#dateformat(date, _hash) ⇒ Object 



184
185
186
187
188
189
190
191
 
# File 'lib/relaton/render/fields/fields.rb', line 184

def dateformat(date, _hash)
  return nil if date.nil?

  i(from to on).each do |k|
    date[k] = ::Relaton::Render::Date.new(date[k], renderer: @r).render
  end
  date_range(date)
end

#draftformat(num, _hash) ⇒ Object 



106
107
108
109
110
111
 
# File 'lib/relaton/render/fields/fields.rb', line 106

def draftformat(num, _hash)
  return nil if num.nil?
  return nil if num.is_a?(Hash) && num[:status].nil? && num[:iteration].nil?

  @r.i18n.draft.sub(/%/, num)
end

#edition_fields_format(hash) ⇒ Object 



35
36
37
38
 
# File 'lib/relaton/render/fields/fields.rb', line 35

def edition_fields_format(hash)
  hash[:edition] = editionformat(hash[:edition_raw])
  hash[:draft] = draftformat(hash[:draft_raw], hash)
end

#editionformat(edn) ⇒ Object 



97
98
99
100
101
102
103
104
 
# File 'lib/relaton/render/fields/fields.rb', line 97

def editionformat(edn)
  return edn unless /^\d+$/.match?(edn)

  num = edn
  @r.edition_number and num = edn.to_i.localize(tw_cldr_lang)
    .to_rbnf_s(*@r.edition_number)
  @r.edition.sub(/%/, num)
end

#extentformat(extent, hash) ⇒ Object 



113
114
115
116
117
118
119
120
121
122
 
# File 'lib/relaton/render/fields/fields.rb', line 113

def extentformat(extent, hash)
  extent.map do |e|
    e1 = e.transform_values { |v| v.is_a?(Hash) ? range(v) : v }
    ret = e.each_with_object({}) do |(k, v), m|
      extentformat1(k, v, m, e1)
      m
    end
    @r.extenttemplate.render(ret.merge(type: hash[:type]))
  end.join("; ")
end

#extentformat1(key, val, hash, norm_hash) ⇒ Object 



124
125
126
127
128
129
 
# File 'lib/relaton/render/fields/fields.rb', line 124

def extentformat1(key, val, hash, norm_hash)
  if i(volume page).include?(key)
    hash["#{key}_raw".to_sym] = norm_hash[key]
    hash[key] = pagevolformat(norm_hash[key], val, key.to_s, false)
  end
end

#mediumformat(hash) ⇒ Object

TODO is not being i18n-alised



57
58
59
60
61
62
63
64
 
# File 'lib/relaton/render/fields/fields.rb', line 57

def mediumformat(hash)
  return nil if hash.nil?

  %w(content genre form carrier size scale).each_with_object([]) do |i, m|
    m << hash[i] if hash[i]
    m
  end.compact.join(", ")
end

#misc_fields_format(hash) ⇒ Object 



40
41
42
43
44
45
46
47
 
# File 'lib/relaton/render/fields/fields.rb', line 40

def misc_fields_format(hash)
  hash[:series] = seriesformat(hash)
  hash[:medium] = mediumformat(hash[:medium_raw])
  hash[:extent] = extentformat(hash[:extent_raw], hash)
  hash[:size] = sizeformat(hash[:size_raw], hash)
  hash[:uri] = uriformat(hash[:uri_raw])
  hash
end

#name_fields_format(hash) ⇒ Object 



18
19
20
21
22
23
24
25
26
27
 
# File 'lib/relaton/render/fields/fields.rb', line 18

def name_fields_format(hash)
  hash[:place] = nameformat(hash[:place_raw]&.map do |x|
                              { nonpersonal: x }
                            end)
  [i(creatornames creators), i(host_creatornames host_creators),
   i(publisher publisher_raw), i(distributor distributor_raw)]
    .each do |k|
    hash[k[0]] = nameformat(hash[k[1]])
  end
end

#nameformat(names) ⇒ Object 



76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/relaton/render/fields/fields.rb', line 76

def nameformat(names)
  return names if names.nil?

  parts = i(surname initials given middle nonpersonal)
  names_out = names.each_with_object({}) do |n, m|
    parts.each do |i|
      m[i] ||= []
      m[i] << n[i]
    end
  end
  @r.nametemplate.render(names_out)
end

#pagevolformat(value, value_raw, type, is_size) ⇒ Object 



164
165
166
167
168
169
170
171
172
173
174
175
 
# File 'lib/relaton/render/fields/fields.rb', line 164

def pagevolformat(value, value_raw, type, is_size)
  return nil if value.nil?

  num = "pl"
  if is_size
    value == "1" and num = "sg"
  else
    value_raw[:to] or num = "sg"
  end
  @r.i18n.l10n(@r.i18n.get[is_size ? "size" : "extent"][type][num]
    .sub(/%/, value))
end

#range(hash) ⇒ Object 



131
132
133
134
135
136
137
138
 
# File 'lib/relaton/render/fields/fields.rb', line 131

def range(hash)
  if hash[:on] then hash[:on]
  elsif hash.has_key?(:from) && hash[:from].nil? then nil
  elsif hash[:from]
    hash[:to] ? "#{hash[:from]}&#x2013;#{hash[:to]}" : hash[:from]
  else hash
  end
end

#role_fields_format(hash) ⇒ Object 



29
30
31
32
33
 
# File 'lib/relaton/render/fields/fields.rb', line 29

def role_fields_format(hash)
  hash[:role] = role_inflect(hash[:creators], hash[:role_raw])
  hash[:host_role] =
    role_inflect(hash[:host_creators], hash[:host_role_raw])
end

#role_inflect(contribs, role) ⇒ Object 



89
90
91
92
93
94
95
 
# File 'lib/relaton/render/fields/fields.rb', line 89

def role_inflect(contribs, role)
  return nil if role.nil? || contribs.size.zero? ||
    %w(author publisher).include?(role)

  number = contribs.size > 1 ? "pl" : "sg"
  @r.i18n.get[role][number] || role
end

#seriesformat(hash) ⇒ Object 



66
67
68
69
70
71
72
73
74
 
# File 'lib/relaton/render/fields/fields.rb', line 66

def seriesformat(hash)
  parts = i(series_title series_abbr series_num series_partnumber
             series_run series_formatted)
  series_out = parts.each_with_object({}) do |i, m|
    m[i] = hash[i]
  end
  t = hash[:type] == "article" ? @r.journaltemplate : @r.seriestemplate
  t.render(series_out)
end

#sizeformat(size, hash) ⇒ Object 



140
141
142
143
144
145
146
147
148
149
 
# File 'lib/relaton/render/fields/fields.rb', line 140

def sizeformat(size, hash)
  return nil unless size

  ret = size.transform_values { |v| @r.i18n.l10n(v.join(" + ")) }
    .each_with_object({}) do |(k, v), m|
      sizeformat1(k, v, m)
      m
    end
  @r.sizetemplate.render(ret.merge(type: hash[:type]))
end

#sizeformat1(key, val, hash) ⇒ Object 



151
152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/relaton/render/fields/fields.rb', line 151

def sizeformat1(key, val, hash)
  case key
  when "volume"
    hash[:volume_raw] = val
    hash[:volume] = pagevolformat(val, nil, "volume", true)
  when "page"
    hash[:page_raw] = val
    hash[:page] = pagevolformat(val, nil, "page", true)
  when "data" then hash[:data] = val
  when "duration" then hash[:duration] = val
  end
end

#uriformat(uri) ⇒ Object 



193
194
195
196
197
 
# File 'lib/relaton/render/fields/fields.rb', line 193

def uriformat(uri)
  return nil if uri.nil? || uri.empty?

  "<link target='#{uri}'>#{uri}</link>"
end