relaton-render 0.4.2 → 3.0.0.pre.alpha.26

data/lib/relaton/render/iso690/elements/title.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      module Elements
+        # Title of the resource (ISO 690 clause 7.3), emphasised by the
+        # style's declared title markers
+        class Title < Element
+          def present?
+            !main_title.empty?
+          end
+
+          # The citation capsule's plain title (the 1.x citetemplate's
+          # "{{ title }}"): the same resolution, no style markers
+          def plain
+            main_title
+          end
+
+          def render
+            text = main_title
+            return text if analytic? && @short
+            if !@short &&
+               (form = @style.title_form_for(@style.kind_for(@model.type)))
+              # the kind's own form carries the whole emphasis
+              return ::Relaton::Render::Iso690::Template.new(form)
+                .evaluate("title" => Template::Field[!text.empty?, text])
+            end
+
+            "#{@style.templates.title_open}#{text}" \
+              "#{@style.templates.title_close}"
+          end
+
+          private
+
+          # ISO 690: analytic titles are not emphasised; the host or
+          # serial carries the emphasis
+          def analytic?
+            %w[component_part serial_part]
+              .include?(@style.kind_for(@model.type))
+          end
+
+          # A typed main title wins; an untyped title is main by
+          # default, but yields to a typed one
+          def main_title
+            titles = Array(@model.title)
+            mains = titles.select { |x| x.type == "main" }
+            mains = titles.select { |x| x.type.nil? } if mains.empty?
+            mains = titles if mains.empty?
+            localized(titles_in_lang(mains).first)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/relaton/render/iso690/elements/updated.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      module Elements
+        # The item's updated date, nested in the creator date group
+        # ("(2018 (updated November 2018))")
+        class Updated < Element
+          def present?
+            !render.empty?
+          end
+
+          def render
+            d = Array(@model.date).find { |x| x.type == "updated" } or
+              return ""
+            value = d.at || d.from || d.to or return ""
+
+            date = value.to_date
+            " (#{label('updated')} #{month(date.month)} #{date.year})"
+          rescue ArgumentError, TypeError
+            ""
+          end
+
+          private
+
+          def label(key)
+            @i18n.label(key)
+          end
+
+          def month(num)
+            @i18n.label("month_#{num}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/relaton/render/iso690/elements.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      # Element registry (ISO 690 clause 7 vocabulary)
+      module Elements
+        autoload :Creator, "relaton/render/iso690/elements/creator"
+        autoload :Title, "relaton/render/iso690/elements/title"
+        autoload :Edition, "relaton/render/iso690/elements/edition"
+        autoload :Medium, "relaton/render/iso690/elements/medium"
+        autoload :Series, "relaton/render/iso690/elements/series"
+        autoload :Production, "relaton/render/iso690/elements/production"
+        autoload :PubDate, "relaton/render/iso690/elements/pub_date"
+        autoload :Identifier, "relaton/render/iso690/elements/identifier"
+        autoload :Location, "relaton/render/iso690/elements/location"
+        autoload :Numeration, "relaton/render/iso690/elements/numeration"
+        autoload :ComponentPart, "relaton/render/iso690/elements/component_part"
+        autoload :Size, "relaton/render/iso690/elements/size"
+        autoload :Extent, "relaton/render/iso690/elements/extent"
+        autoload :Access, "relaton/render/iso690/elements/access"
+        autoload :Stddoc, "relaton/render/iso690/elements/stddoc"
+        autoload :Status, "relaton/render/iso690/elements/status"
+        autoload :Authorizer, "relaton/render/iso690/elements/authorizer"
+        autoload :Citeid, "relaton/render/iso690/elements/citeid"
+        autoload :Updated, "relaton/render/iso690/elements/updated"
+
+        CLASSES = {
+          creator: Creator,
+          title: Title,
+          edition: Edition,
+          medium: Medium,
+          series: Series,
+          production: Production,
+          date: PubDate,
+          identifier: Identifier,
+          location: Location,
+          numeration: Numeration,
+          component_part: ComponentPart,
+          size: Size,
+          extent: Extent,
+          access: Access,
+          stddoc: Stddoc,
+          status: Status,
+          authorizer: Authorizer,
+          citeid: Citeid,
+          updated: Updated,
+        }.freeze
+
+        class << self
+          # Flavors extend the vocabulary through the renderer's
+          # element map: a flavor slot resolves before the built-ins,
+          # scoped to that renderer alone (never process-wide)
+          def resolve(name, elements = {})
+            elements[name.to_sym] || CLASSES.fetch(name, nil)
+          end
+        end
+
+        def self.build(name, model, style:, i18n:, short: false,
+                       elements: {})
+          klass = resolve(name, elements) or return nil
+          klass.new(model, style: style, i18n: i18n, short: short)
+        end
+      end
+    end
+  end
+end

data/lib/relaton/render/iso690/fields.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      # Field resolver: builds the template evaluator's field table from a
+      # relaton model instance. Slots resolve to ISO 690 clause 7 data
+      # elements, to name-form fields of the principal creator, or to the
+      # disambiguator supplied by the citation caller.
+      class Fields
+        ELEMENT_SLOTS = %i[
+          creator title edition medium series production
+          date numeration component_part identifier location size
+          extent access stddoc status citeid authorizer updated
+        ].freeze
+
+        def initialize(model, style:, i18n:, disambiguator: nil,
+                       short: false, elements: {})
+          @model = model
+          @style = style
+          @i18n = i18n
+          @disambiguator = disambiguator.to_s
+          @short = short
+          @elements = elements
+        end
+
+        def to_h
+          table = {}
+          slots.each do |slot|
+            key = slot.to_s.delete("_").downcase
+            table[key] = element_field(slot)
+          end
+          table["role"] = role_field
+          table["dategroup"] = dategroup_field
+          table["disambiguateddate"] = disambiguated_date_field(table["date"])
+          unless table["dategroup"].present?
+            table["dategroup"] = fallback_field(:dategroup)
+          end
+          table.merge(name_fields)
+        end
+
+        # The creators' editor-role marker ("(eds.)", "（編）"), as a
+        # template slot: a creator list that is not all editors cites no
+        # role
+        def role_field
+          creator = Elements.build(:creator, @model, style: @style,
+                                   i18n: @i18n, elements: @elements)
+          return Template::Field[false, ""] unless
+            creator&.present? && creator.respond_to?(:role_marker)
+
+          marker = creator.role_marker
+          marker.empty? ? Template::Field[false, ""] :
+            Template::Field[true, marker]
+        end
+
+        # The date carrying the batch disambiguation suffix ("2022a"):
+        # identity when the caller passes none
+        def disambiguated_date_field(date)
+          return date if @disambiguator.empty? || !date.present?
+
+          Template::Field[true, "#{date.text}#{@disambiguator}"]
+        end
+
+        def fallback_field(slot)
+          fallback = @style.fallback_for(item_kind, slot)
+          fallback ? Template::Field[true, fallback] :
+            Template::Field[false, ""]
+        end
+
+        private
+
+        # The date with the updated date nested ("(2018 (updated
+        # November 2018))"); the bare date slot stays untouched
+        def dategroup_field
+          date = raw_field(:date)
+          updated = raw_field(:updated)
+          return Template::Field[false, ""] if !date.present? &&
+            !updated.present?
+
+          inner = updated.present? ? updated.text : date.text
+          inner = "#{date.text}#{updated.text}" if date.present? &&
+            updated.present?
+          Template::Field[true, "(#{inner})"]
+        end
+
+        private
+
+        def slots
+          ELEMENT_SLOTS | @elements.keys
+        end
+
+        # The element's own render, before any absent-slot fallback:
+        # the creator-date group cites real dates only
+        def raw_field(slot)
+          element_field = build_field(slot)
+          return element_field if element_field.present?
+
+          Template::Field[false, ""]
+        end
+
+        def element_field(slot)
+          field = build_field(slot)
+          return field if field.present?
+
+          fallback = @style.fallback_for(item_kind, slot)
+          return Template::Field[true, fallback] if fallback
+
+          Template::Field[false, ""]
+        end
+
+        def build_field(slot)
+          element = Elements.build(slot, @model, style: @style,
+                                   i18n: @i18n, short: @short,
+                                   elements: @elements) or
+            return Template::Field[false, ""]
+          text = element.render.to_s
+          if element.present? && !text.empty?
+            return Template::Field[true, text]
+          end
+
+          Template::Field[false, ""]
+        end
+
+        def item_kind
+          @style.kind_for(@model.type)
+        end
+
+        def name_fields
+          creator = Elements.build(:creator, @model, style: @style,
+                                   i18n: @i18n, elements: @elements)
+          {
+            "surname" => Template::Field[creator.present?, creator.in_text],
+            "givennames" => Template::Field[!creator.principal_given.empty?,
+                                            creator.principal_given],
+            "disambiguator" => Template::Field[!@disambiguator.empty?,
+                                               @disambiguator],
+          }
+        end
+      end
+    end
+  end
+end

data/lib/relaton/render/iso690/i18n/en.yml

@@ -0,0 +1,47 @@
+lang: en
+labels:
+  edition: "ed"
+  ordinal_word_1: "First"
+  ordinal_word_2: "Second"
+  ordinal_word_3: "Third"
+  ordinal_word_4: "Fourth"
+  ordinal_word_5: "Fifth"
+  ordinal_word_6: "Sixth"
+  ordinal_word_7: "Seventh"
+  ordinal_word_8: "Eighth"
+  ordinal_word_9: "Ninth"
+  ordinal_word_10: "Tenth"
+  size_volume: "vol."
+  size_page: "pp."
+  page: "p. %"
+  pages: "pp. %"
+  volume: "vol. %"
+  issue: "no. %"
+  no_place: "n.p."
+  version: "Version"
+  medium_website: "[website]"
+  viewed: "viewed"
+  month_1: "January"
+  month_2: "February"
+  month_3: "March"
+  month_4: "April"
+  month_5: "May"
+  month_6: "June"
+  month_7: "July"
+  month_8: "August"
+  month_9: "September"
+  month_10: "October"
+  month_11: "November"
+  month_12: "December"
+
+  series_no: "no."
+  report_no: "Report no."
+  available_from: "Available from:"
+  at_url: "At:"
+  in: "In:"
+  and: "and"
+  oxford_comma: ","
+  ed: "ed."
+  eds: "eds."
+  date_range: "–"
+punct: {}

data/lib/relaton/render/iso690/i18n/fr.yml

@@ -0,0 +1,14 @@
+lang: fr
+labels:
+  edition: "éd"
+  series_no: "n°"
+  report_no: "Rapport no."
+  available_from: "Disponible sur :"
+  in: "Dans :"
+  and: "et"
+  oxford_comma: ""
+  ed: "éd."
+  eds: "éd."
+  date_range: "–"
+punct:
+  production_sep: " : "

data/lib/relaton/render/iso690/i18n/ja.yml

@@ -0,0 +1,38 @@
+lang: ja
+labels:
+  edition: "版"
+  size_volume: "巻"
+  size_page: "頁"
+  page: "%頁"
+  pages: "%頁"
+  volume: "巻%"
+  issue: "%号"
+  version: "版"
+  viewed: "閲覧"
+  series_no: "番号"
+  report_no: "報告番号"
+  available_from: "入手先："
+  at_url: "URL："
+  in: "収録："
+  ed: "編"
+  eds: "編"
+  updated: "更新"
+  no_place: "出版地不明"
+  edition_cardinal: "第{{ var1 }}版"
+  edition_ordinal: "第{{ var1 }}版"
+  version_cardinal: "第{{ var1 }}版"
+  in_series: "シリーズ"
+  list_separator: "、 "
+  and: ""
+  oxford_comma: ""
+  date_range: "〜"
+punct:
+  size-join: ""
+  marker-space: ""
+  production_sep: "： "
+  cjk-latin-separator: "、 "
+  period: "。"
+  comma: "、"
+  colon: "："
+  open-paren: "（"
+  close-paren: "）"

data/lib/relaton/render/iso690/i18n.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Relaton
+  module Render
+    module Iso690
+      # Language-specific labels and typographic punctuation, declared per
+      # language in i18n/<lang>.yml. Adding a language adds a YAML
+      # declaration — no code. A style instance's localized strings overlay
+      # the language pack; language-varying intra-element punctuation
+      # (e.g. French " : " production separator) is declared under
+      # `punct:`.
+      class I18n < Lutaml::Model::Serializable
+        attribute :lang, :string, default: "en"
+        attribute :labels, :hash, default: {}
+        attribute :punct, :hash, default: {}
+
+        key_value do
+          map "lang", to: :lang
+          map "labels", to: :labels
+          map "punct", to: :punct
+        end
+
+        def label(key)
+          labels.fetch(key.to_s, key.to_s)
+        end
+
+        def punct_fetch(key, default)
+          punct.fetch(key, default)
+        end
+
+        # Style-instance localized strings win over the language pack.
+        def overlay!(locale)
+          labels.merge!(locale.label_map)
+          punct.merge!(locale.punct || {})
+          self
+        end
+
+        # Runtime label overrides (a caller's i18n hash): the pack's label
+        # names win as the key mapping; unknown keys are ignored.
+        def overlay_hash!(hash)
+          known = %w[
+            edition series_no report_no available_from in and oxford_comma
+            ed eds date_range others no_date no_author at
+            edition_ordinal edition_cardinal version_cardinal
+          ]
+          hash.each do |key, value|
+            labels[key.to_s] = value if known.include?(key.to_s) && !value.nil?
+          end
+          self
+        end
+
+        class << self
+          def load(lang = "en")
+            code = lang.to_s.empty? ? "en" : lang
+            path = File.join(__dir__, "i18n", "#{code}.yml")
+            unless File.file?(path)
+              # 1.x carried declarations for every locale isodoc uses; the
+              # v2 packs are per-style data. Unknown languages fall back to
+              # the English pack rather than killing the whole conversion.
+              fallback_warn(code)
+              path = File.join(__dir__, "i18n", "en.yml")
+              raise ArgumentError, "no i18n declarations for language #{code}" unless File.file?(path)
+              # The pack supplies the labels; the requested language still
+              # governs localization (bilingual titles select by it)
+              return from_yaml(File.read(path)).tap { |i| i.lang = code }
+            end
+
+            from_yaml(File.read(path))
+          end
+
+          def fallback_warn(code)
+            (@fallback_warned ||= {})[code] and return
+            @fallback_warned[code] = true
+            warn "relaton-render: no i18n declarations for language " \
+                 "#{code}; falling back to en"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/relaton/render/iso690/identifier_kinds.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      # Standard and persistent identifiers (ISO 690 clause 7.11): each
+      # identifier kind carries its own rendering method. Kinds are keyed by
+      # the docidentifier's type attribute — never guessed from content.
+      # Flavors register additional kinds (e.g. Pubid::Iala's MRN).
+      module IdentifierKinds
+        KINDS = {
+          "DOI" => ->(content) { "https://doi.org/#{content}" },
+          "ISBN" => ->(content) { "ISBN #{content}" },
+          "ISSN" => ->(content) { "ISSN #{content}" },
+          "URN" => ->(content) { content },
+          "MRN" => ->(content) { content },
+        }.freeze
+
+        class << self
+          def render(docidentifier)
+            content = docidentifier.content.to_s
+            kind = KINDS[docidentifier.type]
+            kind ? kind.call(content) : content
+          end
+        end
+      end
+    end
+  end
+end

data/lib/relaton/render/iso690/index_renderer.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      # A bibliographic index: the ordered reference list, laid out per the
+      # BibliographicStyle instance. Sorting follows the style's declared
+      # sortKey rules (creator, then date); numbering is layout data.
+      class IndexRenderer
+        def initialize(style: "author-date", lang: "en", script: "Latn")
+          @style = Style.load(style)
+          @i18n = I18n.load(lang).overlay!(@style.scheme.locale)
+          @renderer = Renderer.new(style: style, lang: lang, script: script)
+        end
+
+        # The reference strings, sorted per the style's sortKey rules.
+        def references(models)
+          sort_rules = @style.sort_keys
+          fields = models.to_h { |m| [m, field_table(m)] }
+          models.sort do |a, b|
+            fa = fields[a]
+            fb = fields[b]
+            sort_rules.each do |rule|
+              cmp = key_of(fa, rule) <=> key_of(fb, rule)
+              next if cmp.zero?
+
+              break(rule.descending? ? -cmp : cmp)
+            end || 0
+          end.map { |model| @renderer.render(model) }
+        end
+
+        # The laid-out index: numbered entries per the layout rules
+        # (arabic by default; "none" renders bare references).
+        def render(models, numbering: "arabic")
+          refs = references(models)
+          return refs if numbering == "none"
+
+          refs.each_with_index.map { |ref, i| "#{i + 1}. #{ref}" }
+        end
+
+        private
+
+        def field_table(model)
+          Fields.new(model, style: @style, i18n: @i18n).to_h
+        end
+
+        def key_of(fields, rule)
+          field = fields[rule.attribute.to_s.delete("_").downcase]
+          return "" if field.nil?
+
+          text = field.respond_to?(:text) ? field.text : field.to_s
+          text.downcase
+        end
+      end
+    end
+  end
+end

data/lib/relaton/render/iso690/kinds.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      # The vocabulary mapping from a bibliographic item's wire type value
+      # to its ISO 690 clause 8 resource kind (TemplateType). This table is
+      # the engine's charter — style instances select perType templates on
+      # kinds and never enumerate type synonyms. Unmapped values fall to
+      # the report kind (clause 8.11), the runner's fallback.
+      module Kinds
+        TO_KIND = {
+          "book" => "monograph",
+          "booklet" => "monograph",
+          "manual" => "monograph",
+          "proceedings" => "monograph",
+          "thesis" => "monograph",
+          "standard" => "report",
+          "techreport" => "report",
+          "report" => "report",
+          "patent" => "patent",
+          "journal" => "continuing",
+          "serial" => "continuing",
+          "article-journal" => "continuing",
+          "article-magazine" => "continuing",
+          "inbook" => "component_part",
+          "incollection" => "component_part",
+          "inproceedings" => "component_part",
+          "article" => "serial_part",
+          "software" => "online",
+          "unpublished" => "online",
+          "dataset" => "online",
+          "website" => "webdoc",
+          "webresource" => "webdoc",
+          "webpage" => "online",
+          "online" => "online",
+        }.freeze
+
+        DEFAULT_KIND = "report"
+
+        class << self
+          def mapped?(type)
+            TO_KIND.key?(type.to_s)
+          end
+        end
+
+        def self.kind_for(type)
+          TO_KIND.fetch(type.to_s, DEFAULT_KIND)
+        end
+      end
+    end
+  end
+end