Class: Pubid::Core::Renderer::Base

Inherits:
Object
  • Object
show all
Defined in:
lib/pubid/core/renderer/base.rb

Direct Known Subclasses

Urn

Constant Summary collapse

LANGUAGES = 
{
  "ru" => "R",
  "fr" => "F",
  "en" => "E",
  "ar" => "A",
  "es" => "S",
}.freeze
SEMANTIC_CLASSES = 
{
  publisher: "publisher",
  number: "docnumber",
  part: "part",
  year: "year",
  edition: "edition",
  amendments: "amendment",
  corrigendums: "corrigendum",
  language: "language",
  typed_stage: "doctype",
  stage: "stage",
  iteration: "iteration",
  addendum: "addendum",
}.freeze
SEPARATOR_CHARS = 
Set.new(["-", ":", "/", " ", ",", "."]).freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(params) ⇒ Base

Returns a new instance of Base.



32
33
34
 
# File 'lib/pubid/core/renderer/base.rb', line 32

def initialize(params)
  @params = params
end

Instance Attribute Details

#params ⇒ Object

Returns the value of attribute params.



5
6
7
 
# File 'lib/pubid/core/renderer/base.rb', line 5

def params
  @params
end

Instance Method Details

#annotate_value(key, rendered_value) ⇒ String

Wraps rendered value in a <span> tag with a semantic CSS class. Leading/trailing separator characters are preserved outside the span.

Parameters:

  • key (Symbol) —

    parameter key (e.g. :publisher, :number)

  • rendered_value (String) —

    the rendered string value

Returns:

  • (String) —

    annotated or original value



41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/pubid/core/renderer/base.rb', line 41

def annotate_value(key, rendered_value)
  css_class = SEMANTIC_CLASSES[key]
  return rendered_value if css_class.nil?

  str = rendered_value.to_s
  return str if str.empty?

  # Extract leading separators
  leading = ""
  while !str.empty? && SEPARATOR_CHARS.include?(str[0])
    leading << str[0]
    str = str[1..]
  end

  # Extract trailing separators
  trailing = ""
  while !str.empty? && SEPARATOR_CHARS.include?(str[-1])
    trailing = str[-1] + trailing
    str = str[0..-2]
  end

  return rendered_value if str.empty?

  "#{leading}<span class=\"#{css_class}\">#{str}</span>#{trailing}"
end

#prerender(**opts) ⇒ Renderer::Base

Prerender parameters and store in @prerendered_params

Parameters:

  • opts (Hash) —

    options for render method, eg. { with_language_code: :single, with_date: true }

Returns:



70
71
72
73
74
 
# File 'lib/pubid/core/renderer/base.rb', line 70

def prerender(**opts)
  @prerendered_params = prerender_params(@params, opts)
  @prerendered_params.default = ""
  self
end

#prerender_params(params, opts) ⇒ Object 



83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/pubid/core/renderer/base.rb', line 83

def prerender_params(params, opts)
  params.map do |key, value|
    next unless value
    rendered = if respond_to?("render_#{key}")
                 send("render_#{key}", value, opts, params)
               else
                 value
               end
    # Only annotate values that have been rendered to their final String
    # form here. Some flavors (e.g. Pubid::Iso) defer rendering of certain
    # keys to a second phase in their overridden #render_identifier: their
    # render_<key> returns the domain object (e.g. a Stage) unchanged so it
    # can be inspected and rendered later. Wrapping such an object in a span
    # now would (a) stringify it prematurely and (b) replace the object with
    # a String, breaking the second phase (which calls Stage methods like
    # #empty_abbr?). Those keys are annotated by the subclass in phase two.
    rendered = annotate_value(key, rendered) if opts[:annotated] && rendered.is_a?(String)
    [key, rendered]
  end.compact.to_h
end

#render(with_date: true, with_language_code: :iso, annotated: false, **args) ⇒ Object

Render identifier

Parameters:

  • with_date (Boolean) (defaults to: true) —

    include year in output

  • with_language_code (:iso, :single) (defaults to: :iso) —

    render document language as 2-letter ISO 639-1 language code or single code



141
142
143
 
# File 'lib/pubid/core/renderer/base.rb', line 141

def render(with_date: true, with_language_code: :iso, annotated: false, **args)
  render_base_identifier(**args.merge({ with_date: with_date, with_language_code: with_language_code, annotated: annotated})) + @prerendered_params[:language].to_s
end

#render_amendments(amendments, _opts, _params) ⇒ Object 



162
163
164
 
# File 'lib/pubid/core/renderer/base.rb', line 162

def render_amendments(amendments, _opts, _params)
  amendments.sort.map(&:render_pubid).join("+")
end

#render_base_identifier(**args) ⇒ Object 



76
77
78
79
80
 
# File 'lib/pubid/core/renderer/base.rb', line 76

def render_base_identifier(**args)
  prerender(**args)

  render_identifier(@prerendered_params)
end

#render_corrigendums(corrigendums, _opts, _params) ⇒ Object 



166
167
168
 
# File 'lib/pubid/core/renderer/base.rb', line 166

def render_corrigendums(corrigendums, _opts, _params)
  corrigendums.sort.map(&:render_pubid).join("+")
end

#render_identifier(params) ⇒ Object 



145
146
147
 
# File 'lib/pubid/core/renderer/base.rb', line 145

def render_identifier(params)
  render_base(params)
end

#render_language(language, opts, _params) ⇒ Object 



179
180
181
182
183
184
185
 
# File 'lib/pubid/core/renderer/base.rb', line 179

def render_language(language, opts, _params)
  if opts[:with_language_code] == :single
    "(#{LANGUAGES[language]})"
  else
    "(#{language})"
  end
end

#render_part(part, opts, _params) ⇒ Object 



171
172
173
 
# File 'lib/pubid/core/renderer/base.rb', line 171

def render_part(part, opts, _params)
  "-#{part}"
end

#render_publisher(publisher, _opts, params) ⇒ Object 



149
150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/pubid/core/renderer/base.rb', line 149

def render_publisher(publisher, _opts, params)
  return publisher unless params[:copublisher]

  case params[:copublisher]
  when Array
    ([publisher] + params[:copublisher].map(&:to_s).sort.map(&:to_s)).map do |pub|
      pub.gsub('-', '/')
    end.join("/")
  else
    [publisher, params[:copublisher]].join("/")
  end
end

#render_supplement(supplement_params, **args) ⇒ Object

Renders amendment and corrigendum when applied through identifier type



105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/pubid/core/renderer/base.rb', line 105

def render_supplement(supplement_params, **args)
  base = if supplement_params[:base].type == :amd
           # render inner amendment (cor -> amd -> base)
           render_supplement(supplement_params[:base].to_h, **args)
         else
           self.class.new(supplement_params[:base].to_h).render_base_identifier(
             # always render year for identifiers with supplement
             **args.merge({ with_date: true }),
           )
         end
  supplement = case supplement_params[:typed_stage].type.type
               when :amd
                 render_amendments(
                   [Pubid::Iso::Amendment.new(**supplement_params.slice(:number, :year, :typed_stage, :edition, :iteration))],
                   args,
                   nil,
                 )
               when :cor
                 render_corrigendums(
                   [Pubid::Iso::Corrigendum.new(**supplement_params.slice(:number, :year, :typed_stage, :edition, :iteration))],
                   args,
                   nil,
                 )
                 # copy parameters from Identifier only supported by Corrigendum
               end

  if supplement_params[:base].language
    base + supplement + render_language(supplement_params[:base].language, args, nil)
  else
    base + supplement
  end
end

#render_year(year, opts, _params) ⇒ Object 



175
176
177
 
# File 'lib/pubid/core/renderer/base.rb', line 175

def render_year(year, opts, _params)
  opts[:with_date] && ":#{year}" || ""
end