relaton 3.0.7 → 3.1.0

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

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      # The named-rule registry: presentation-of-models implementations
+      # the engine ships once, addressable from pack data as
+      # rules: { slot: rule_name }. Flavors migrate their ELEMENTS maps
+      # onto registered rules; nothing references a flavor class.
+      module Rules
+        # The bare status: unparenthesized, no label ("Recommendation")
+        class BareStatus < Elements::Status
+          def render
+            stage.to_s
+          end
+        end
+
+        # The IEEE-SA identifiers: DOI and ISBN carry their kind label
+        # with a colon ("DOI: https://doi.org/…")
+        class IeeeIdentifier < Elements::Identifier
+          private
+
+          def render_id(docidentifier)
+            return "#{docidentifier.type}: #{docidentifier.content}" if
+              %w[DOI ISBN].include?(docidentifier.type)
+
+            super
+          end
+        end
+
+        # The IEEE component part: "in Pellegrini, A. D., and P. K.
+        # Smith (eds.): <em>host</em>, production" — the names first,
+        # the eds marker in the close paren, the host title after the
+        # colon, the production after a comma
+        class IeeeComponentPart < Elements::ComponentPart
+          def render
+            h = host or return ""
+            out = +"in #{host_person_names(h)} (#{eds_label(h)}): "
+            out += host_title.to_s
+            production = Elements::Production
+              .new(h, style: @style, i18n: @i18n).render.to_s
+            out += ", #{production}" unless production.empty?
+            out
+          end
+
+          private
+
+          def host_editors(h)
+            Array(h.contributor).select { |c| has_role?(c, "editor") }
+          end
+
+          def eds_label(h)
+            @i18n.label(host_editors(h).one? ? "ed" : "eds")
+          end
+
+          # The IEEE host form: the first editor inverted, subsequent
+          # editors direct
+          def host_person_names(h)
+            host_editors(h).each_with_index.map { |c, i|
+              person = c.person or next ""
+
+              if i.zero?
+                [person_surname(person), person_given(person)]
+                  .reject(&:empty?).join(", ")
+              else
+                [person_given(person), person_surname(person)]
+                  .reject(&:empty?).join(" ")
+              end
+            }.reject(&:empty?).then { |names| join_names(names) }
+          end
+        end
+
+        # The IEEE access date, bare and unbracketed
+        # ("accessed September 3, 2019")
+        class IeeeAccess < Elements::Access
+          def render
+            "#{@i18n.label('viewed')} #{date_text}"
+          end
+        end
+
+        # The IEEE medium, capitalized and carrying its own trailing
+        # comma ("Dataset,", "Preprint,")
+        class IeeeMedium < Elements::Medium
+          private
+
+          def medium
+            m = @model.medium or return ""
+            text = m.carrier.to_s
+            text = m.genre.to_s if text.empty?
+            text = [m.form.to_s, m.size.to_s].reject(&:empty?)
+              .join(", ") if text.empty?
+            text.empty? ? "" : "#{text.sub(/^\w/) { |c| c.upcase }},"
+          end
+        end
+
+        # The ITU identifiers: ISBN and ISSN carry their kind label
+        # with a colon ("ISBN 92-61-12521-9")
+        class ItuIdentifier < Elements::Identifier
+          private
+
+          def render_id(docidentifier)
+            return "#{docidentifier.type}: #{docidentifier.content}" if
+              %w[ISBN ISSN].include?(docidentifier.type)
+
+            super
+          end
+        end
+
+        # The IHO creator cites the affiliation's organization name
+        # after the creator list ("D. Balenson, Internet Engineering
+        # Task Force")
+        class IhoCreator < Elements::Creator
+          def render
+            out = super.to_s
+            aff = affiliation_names
+            out.empty? || aff.empty? ? out : "#{out}, #{aff}"
+          end
+
+          private
+
+          def affiliation_names
+            creators.filter_map do |c|
+              person = c.person or next ""
+
+              Array(person.affiliation).filter_map do |a|
+                Array(a.organization&.name).map(&:content).first.to_s
+              end.reject(&:empty?).first.to_s
+            end.reject(&:empty?).uniq.join(", ")
+          end
+        end
+
+        # The IHO edition cites only for IHO-published documents, as
+        # the raw numeric edition carrying its own label ("edition
+        # 3.1.0"); worded editions ("Revision 1") cite as nothing
+        class IhoEdition < Elements::Edition
+          def render
+            return "" unless iho_publisher?
+
+            text = edition_text
+            text.match?(/\A\d/) ? " edition #{text}" : ""
+          end
+
+          private
+
+          def edition_text
+            raw = @model.edition
+            raw.respond_to?(:content) ? raw.content.to_s : raw.to_s
+          end
+
+          def iho_publisher?
+            Array(@model.contributor).any? do |c|
+              next false unless Array(c.role).any? do |r|
+                r.is_a?(String) ? r == "publisher" : r.type == "publisher"
+              end
+
+              org = c.organization or next false
+              names = Array(org.name).map(&:content) +
+                      [org.abbreviation&.content.to_s]
+              # a string array: %w[] would split the organization's
+              # full name into words and never match it
+              names.any? do |n|
+                ["IHO", "International Hydrographic Organization"]
+                  .include?(n)
+              end
+            end
+          end
+        end
+
+        # The NIST, BIPM and JIS rule sets live in their own
+        # autoloaded sections
+        autoload :Nist, "relaton/render/iso690/rules/nist"
+        autoload :Bipm, "relaton/render/iso690/rules/bipm"
+        autoload :Jis, "relaton/render/iso690/rules/jis"
+
+        REGISTRY = {
+          "status_bare" => BareStatus,
+          "itu_identifier" => ItuIdentifier,
+          "ieee_identifier" => IeeeIdentifier,
+          "ieee_component_part" => IeeeComponentPart,
+          "ieee_access" => IeeeAccess,
+          "ieee_medium" => IeeeMedium,
+          "nist_creator" => Nist::NistCreator,
+          "nist_date" => Nist::NistDate,
+          "nist_serial_date" => Nist::NistSerialDate,
+          "nist_series" => Nist::NistSeries,
+          "nist_component_part" => Nist::NistComponentPart,
+          "nist_identifier" => Nist::NistIdentifier,
+          "nist_publisher" => Nist::NistPublisher,
+          "nist_draft" => Nist::NistDraft,
+          "iho_creator" => IhoCreator,
+          "iho_edition" => IhoEdition,
+          "bipm_creator" => Bipm::BipmCreator,
+          "bipm_component_part" => Bipm::BipmComponentPart,
+          "bipm_production" => Bipm::BipmProduction,
+          "bipm_extent" => Bipm::BipmExtent,
+          "bipm_medium" => Bipm::BipmMedium,
+          "bipm_edition" => Bipm::BipmEdition,
+          "bipm_volume" => Bipm::BipmVolume,
+          "jis_component_part" => Jis::JisComponentPart,
+          "jis_series" => Jis::JisSeries,
+          "jis_extent" => Jis::JisExtent,
+        }.freeze
+
+        class << self
+          def register(name, klass)
+            REGISTRY[name.to_s] = klass
+          end
+
+          # A pack's rule selections become the renderer's element map;
+          # caller-supplied elements win over the pack's selections
+          def resolve(rules, elements = {})
+            Array(rules).to_h { |slot, name| [slot.to_sym, fetch(name)] }
+              .merge(elements || {})
+          end
+
+          private
+
+          def fetch(name)
+            REGISTRY.fetch(name.to_s) do
+              raise ArgumentError, "unknown citation style rule #{name}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/relaton/render/iso690/style/locale.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      class Style
+        # LocalizedStrings: per-style overrides of the language pack's
+        # connective strings, keyed as in the CitationStyle model.
+        class Locale < Lutaml::Model::Serializable
+          attribute :conj, :string
+          attribute :others, :string
+          attribute :no_date, :string
+          attribute :no_author, :string
+          attribute :in_str, :string
+          attribute :at, :string
+          attribute :available_at, :string
+          # Arbitrary label overrides (edition words, join punctuation,
+          # size units): merged over the language pack verbatim.
+          attribute :labels, :hash, default: -> { {} }
+          # Typographic punctuation overrides (production order and
+          # separator), declared as in the language packs
+          attribute :punct, :hash, default: -> { {} }
+
+          key_value do
+            map "and", to: :conj
+            map "others", to: :others
+            map "noDate", to: :no_date
+            map "noAuthor", to: :no_author
+            map "in", to: :in_str
+            map "at", to: :at
+            map "availableAt", to: :available_at
+            map "labels", to: :labels
+            map "punct", to: :punct
+          end
+
+          LABEL_FOR = {
+            "conj" => "and", "others" => "others", "no_date" => "no_date",
+            "no_author" => "no_author", "in_str" => "in", "at" => "at",
+            "available_at" => "available_from",
+          }.freeze
+
+          # The named attributes' label map alone: a delta's named
+          # attribute (availableAt) outranks the base pack's labels
+          # hash carrying the same label key
+          def named_label_map
+            LABEL_FOR.filter_map do |attr, label|
+              value = public_send(attr)
+              [label, value] unless value.nil?
+            end.to_h
+          end
+
+          def label_map
+            named_label_map.merge(labels || {})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/relaton/render/iso690/style/name_form.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      class Style
+        # How personal names are formed, as declared by the style's
+        # citation scheme (relaton-models NameFormRules).
+        class NameForm < Lutaml::Model::Serializable
+          attribute :initials, :boolean, default: -> { false }
+          attribute :given_name_first, :boolean, default: -> { false }
+          # Where an all-editor creator list's role marker sits relative
+          # to the name's terminating period: "glue" renders
+          # "NAME (eds.)." (the name-date default), "afterPeriod"
+          # renders "NAME. (eds.)" (ISO 690 clause-flavour).
+          attribute :role_placement, :string, default: "glue"
+          # A completename is rendered, not decomposed; styles that
+          # upcase inverted names may declare the completename treatment
+          attribute :completename_upcase, :boolean, default: -> { false }
+          # Every personal name takes the inverted form (surname first),
+          # not just the principal creator
+          attribute :inverted_all, :boolean, default: -> { false }
+          # "serial": the oxford comma appears at every gap of the
+          # creator list, including between two names
+          attribute :list_style, :string, default: ""
+          # Organization names take the inverted form's casing; small-cap
+          # styles keep the declared case
+          attribute :org_upcase, :boolean, default: -> { true }
+          # When no personal creator exists, the creator slot falls back
+          # to the publisher's abbreviation ("ISO: ISO 712, ...")
+          attribute :creator_fallback, :string
+          # A lone editor still carries the role marker ("(ed.)")
+          attribute :lone_editor_marked, :boolean, default: -> { false }
+          # Initials without their trailing periods ("Nixon RM")
+          attribute :initials_period, :boolean, default: -> { true }
+          # The inverted form's surname casing: the name-date convention
+          # upcases; small-cap styles keep the declared case
+          attribute :surname_upcase, :boolean, default: -> { true }
+          # Initials are a list; this separates them ("J. K." vs "J.K.")
+          attribute :initials_separator, :string, default: " "
+          # The first forename cites in full, the rest as initials
+          # ("Milena S."; document-history name forms)
+          attribute :subsequent_initials, :boolean, default: -> { false }
+          # The direct-order surname casing after the first creator:
+          # the name-date convention upcases
+          attribute :subsequent_surname_upcase, :boolean,
+                    default: -> { true }
+          # At this many creators the creator list truncates to the
+          # first etalDisplay names with "et al." (0 disables)
+          attribute :etal_count, :integer, default: 0
+          attribute :etal_display, :integer, default: 0
+          # The in-text cite truncates separately from the creator
+          # list: at this many creators it shows the first
+          # inTextEtalDisplay names with "et al." (0 disables; IEEE
+          # cites 3+ as "Aluffi et al." while listing 6 in the
+          # bibliography)
+          attribute :in_text_etal_count, :integer, default: 0
+          attribute :in_text_etal_display, :integer, default: 1
+          # Editor lists carry the role marker ("(Eds.)")
+          attribute :editors_marked, :boolean, default: -> { true }
+
+          key_value do
+            map "initials", to: :initials
+            map "givenNameFirst", to: :given_name_first
+            map "rolePlacement", to: :role_placement
+            map "completenameUpcase", to: :completename_upcase
+            map "invertedAll", to: :inverted_all
+            map "listStyle", to: :list_style
+            map "orgUpcase", to: :org_upcase
+            map "creatorFallback", to: :creator_fallback
+            map "loneEditorMarked", to: :lone_editor_marked
+            map "initialsPeriod", to: :initials_period
+            map "surnameUpcase", to: :surname_upcase
+            map "initialsSeparator", to: :initials_separator
+            map "subsequentInitials", to: :subsequent_initials
+            map "subsequentSurnameUpcase", to: :subsequent_surname_upcase
+            map "etalCount", to: :etal_count
+            map "etalDisplay", to: :etal_display
+            map "inTextEtalCount", to: :in_text_etal_count
+            map "inTextEtalDisplay", to: :in_text_etal_display
+            map "editorsMarked", to: :editors_marked
+          end
+        end
+      end
+    end
+  end
+end

data/lib/relaton/render/iso690/style/scheme.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      class Style
+        # CitationScheme: the citation system, its name form and its
+        # localized strings (relaton-models CitationScheme).
+        class Scheme < Lutaml::Model::Serializable
+          attribute :system, :string, default: "name-date"
+          attribute :name_form, NameForm, default: -> { NameForm.new }
+          attribute :locale, Locale, default: -> { Locale.new }
+          attribute :home_docid_type, :string, collection: true
+          attribute :default_kind, :string, default: ""
+
+          # The renderings' short cite takes the reference form with the
+      # first-biblio marker (the 1.x citetemplate short), not the
+      # citation template
+      attribute :short_from_reference, :boolean, default: -> { false }
+
+      key_value do
+            map "system", to: :system
+            map "nameForm", to: :name_form
+            map "locale", to: :locale
+            map "homeDocidType", to: :home_docid_type
+            map "defaultKind", to: :default_kind
+            map "shortFromReference", to: :short_from_reference
+          end
+        end
+      end
+    end
+  end
+end

data/lib/relaton/render/iso690/style/sort_rule.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      class Style
+        # SortRule: one ordering key of a bibliographic index sort
+        # (relaton-models SortRule).
+        class SortRule < Lutaml::Model::Serializable
+          attribute :attribute, :string
+          attribute :order, :string
+
+          key_value do
+            map "attribute", to: :attribute
+            map "order", to: :order
+          end
+
+          def descending?
+            order == "descending"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/relaton/render/iso690/style/template_map.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      class Style
+        # TemplateMap: citation and reference templates as data, plus the
+        # title emphasis markers and the first-creator name form. Slots
+        # name ISO 690 clause 7 data elements or name-form fields.
+        class TemplateMap < Lutaml::Model::Serializable
+          attribute :title_open, :string, default: "_"
+          attribute :title_close, :string, default: "_"
+          attribute :citation, :string, default: "{{surname}}, {{date}}"
+          attribute :reference, :string
+          attribute :name, :string, default: "{{surname}}, {{givenNames}}"
+          attribute :series, :string, default: ""
+          attribute :uri, :string, default: ""
+          attribute :creators, :string, default: ""
+          attribute :uri_short, :string, default: ""
+          # "first": cite only the first identifier (1.x
+          # authoritative_identifier|first styles)
+          attribute :identifier_mode, :string, default: "all"
+
+          key_value do
+            map "titleOpen", to: :title_open
+            map "titleClose", to: :title_close
+            map "citation", to: :citation
+            map "reference", to: :reference
+            map "name", to: :name
+          map "series", to: :series
+          map "uri", to: :uri
+          map "creators", to: :creators
+          map "uriShort", to: :uri_short
+          map "identifierMode", to: :identifier_mode
+          end
+        end
+      end
+    end
+  end
+end

data/lib/relaton/render/iso690/style/type_template.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      class Style
+        # TypeTemplate: the template variant for one bibliographic item
+        # type, selected by data lookup (relaton-models TypeTemplate).
+        class TypeTemplate < Lutaml::Model::Serializable
+          attribute :type, :string
+          attribute :template, :string
+          attribute :series, :string
+          attribute :title, :string
+          # Per-slot form overrides for the production and the
+          # authorizer: wrappers over the element's own render, so a
+          # kind can carry its slot's separator in the form
+          # (", {{production}}" over the engine's ". " glue)
+          attribute :production, :string
+          attribute :authorizer, :string
+          attribute :home, :boolean
+          attribute :fallbacks, :hash, default: -> { {} }
+          # The short-cite template for this kind; absent falls back to
+          # the reference template in short mode
+          attribute :short, :string
+          # Render the style's no_place label when the publisher has no
+          # place (the book-family templates of some flavors)
+          attribute :no_place, :boolean
+
+          key_value do
+            map "type", to: :type
+            map "template", to: :template
+            map "series", to: :series
+            map "title", to: :title
+            map "production", to: :production
+            map "authorizer", to: :authorizer
+            map "home", to: :home
+            map "fallbacks", to: :fallbacks
+            map "short", to: :short
+            map "noPlace", to: :no_place
+          end
+        end
+      end
+    end
+  end
+end