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
 
# 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
    rendered = annotate_value(key, rendered) if opts[:annotated] && rendered
    [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



133
134
135
 
# File 'lib/pubid/core/renderer/base.rb', line 133

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 



154
155
156
 
# File 'lib/pubid/core/renderer/base.rb', line 154

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 



158
159
160
 
# File 'lib/pubid/core/renderer/base.rb', line 158

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

#render_identifier(params) ⇒ Object 



137
138
139
 
# File 'lib/pubid/core/renderer/base.rb', line 137

def render_identifier(params)
  render_base(params)
end

#render_language(language, opts, _params) ⇒ Object 



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

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

#render_part(part, opts, _params) ⇒ Object 



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

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

#render_publisher(publisher, _opts, params) ⇒ Object 



141
142
143
144
145
146
147
148
149
150
151
152
 
# File 'lib/pubid/core/renderer/base.rb', line 141

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



97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
# File 'lib/pubid/core/renderer/base.rb', line 97

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 



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

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