relaton 3.0.6 → 3.0.8

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

@@ -0,0 +1,129 @@
+require "json"
+
+module Relaton
+  module Render
+    module Iso690
+      # Imports a CSL style's common properties into a CitationStyle instance
+      # (styles as data, the downgrade direction: CSL's element-list engine
+      # is strictly richer, so the import covers what the instance format can
+      # express and lists everything it dropped in `requires`).
+      #
+      # Mapped: the info title, the citation/reference variable runs (text
+      # elements over the CSL variables, via the crosswalk below), the
+      # name-form scalars (initialize-with, name-as-sort-order, et-al
+      # lengths), the year-suffix disambiguation, and the delimiters.
+      module CslImport
+        # CSL variable -> the ISO 690 slot the engine resolves.
+        VARIABLE_SLOTS = {
+          "author" => "creator", "editor" => "creator",
+          "title" => "title", "container-title" => "series",
+          "edition" => "edition", "publisher" => "production",
+          "publisher-place" => "location", "issued" => "date",
+          "DOI" => "identifier", "URL" => "identifier", "PMID" => "identifier",
+          "number" => "numeration", "volume" => "numeration",
+          "page" => "numeration", "medium" => "medium",
+          "accessed" => "access", "version" => "edition",
+        }.freeze
+
+        # CSL features the import drops, reported in `requires` so a resolver
+        # fails loudly instead of silently mis-rendering.
+        DROPPED_FEATURES = [
+          "csl macros (macro elements are not data-expressible)",
+          "csl groups with conditional rendering (match= attributes)",
+          "csl per-locator templates",
+        ].freeze
+
+        class << self
+          # Build a CitationStyle instance from a parsed CSL style JSON.
+          #
+          # @param csl [Hash] parsed CSL style
+          # @return [Style]
+          def style(csl)
+            Style.new(
+              name: style_name(csl),
+              family: "iso690",
+              requires: dropped_features(csl),
+              scheme: scheme(csl),
+              templates: templates(csl),
+            )
+          end
+
+          # Parse a CSL style JSON string and build the instance.
+          #
+          # @param [String] json
+          # @return [Style]
+          def from_json(json)
+            style(JSON.parse(json))
+          end
+
+          private
+
+          def style_name(csl)
+            title = csl.dig("info", "title").to_s
+            title.empty? ? "Imported CSL style" : "#{title} (CSL import)"
+          end
+
+          def dropped_features(csl)
+            feats = DROPPED_FEATURES.dup
+            feats << "csl bibliography section" if csl["bibliography"]
+            feats << "csl locales" if csl["locales"]
+            feats
+          end
+
+          def scheme(csl)
+            Style::Scheme.new(
+              system: "name-date",
+              name_form: name_form(csl),
+              locale: Style::Locale.new(no_date: "n.d."),
+            )
+          end
+
+          def name_form(csl)
+            citation = csl["citation"] || {}
+            initialize_with = citation["initialize-with"]
+            Style::NameForm.new(
+              initials: !initialize_with.nil?,
+              initials_separator: initialize_with.is_a?(String) ? initialize_with : " ",
+              initials_period: initialize_with.to_s.include?("."),
+              inverted_all: citation["name-as-sort-order"].to_s == "all",
+            )
+          end
+
+          def templates(csl)
+            citation_elements = csl.dig("citation", "elements") || []
+            reference_elements = csl.dig("bibliography", "elements") || []
+            Style::TemplateMap.new(
+              citation: element_template(
+                citation_elements, csl.dig("citation", "delimiter") || ", ",
+                "{{creator}}, {{date}}{{disambiguator}}",
+              ),
+              reference: element_template(
+                reference_elements, csl.dig("bibliography", "delimiter") || ". ",
+                "{{creator}}. {{title}}. {{edition}}. {{series}}. {{production}}, {{date}}. {{identifier}}. {{location}}.",
+              ),
+              name: "{{surname}}, {{givenNames}}",
+            )
+          end
+
+          # Flatten CSL text/variable elements into a slot template. Non-text
+          # elements (macros, groups, conditions) contribute nothing: the
+          # import covers flat variable runs only.
+          def element_template(elements, delimiter, fallback)
+            slots = elements.filter_map do |el|
+              next unless el.is_a?(Hash)
+
+              # A CSL text element nests its variable: {"text": {"variable": ...}}
+              variable = el.dig("text", "variable") || el["variable"]
+              slot = variable && VARIABLE_SLOTS[variable]
+              "{{#{slot}}}" if slot
+            end
+            slots = slots.uniq
+            return fallback if slots.empty?
+
+            slots.join(delimiter)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      # Base data element (ISO 690 clause 7). An element wraps typed data
+      # taken from the relaton model instance; #present? is the omission
+      # predicate, #render the element's formatting method. Punctuation
+      # between elements belongs to the kind/style, not the element.
+      class Element
+        def initialize(model, style:, i18n:, kind: nil, short: false)
+          @model = model
+          @style = style
+          @i18n = i18n
+          @kind = kind
+          @short = short
+        end
+
+        def present?
+          false
+        end
+
+        def render
+          nil
+        end
+
+        private
+
+        def localized(value)
+          value&.content.to_s
+        end
+
+        # Localizable values scoped to the render language: the variants
+        # declared in that language, or all of them when none matches
+        def titles_in_lang(values)
+          titles = Array(values)
+          in_lang = titles.select { |t| Array(t.language).include?(@i18n.lang) }
+          in_lang.empty? ? titles : in_lang
+        end
+
+        def contributors(role)
+          Array(@model.contributor).select { |c| has_role?(c, role) }
+        end
+
+        def has_role?(contributor, role)
+          Array(contributor.role).any? do |r|
+            r.is_a?(String) ? r == role : r.type == role
+          end
+        end
+
+        def org_name(contributor)
+          shown = ->(n) do
+            text = localized(n)
+            @style.scheme.name_form.org_upcase ? text.upcase : text
+          end
+          name = Array(contributor.organization&.name)
+            .map(&shown).join(", ")
+          abbrev = localized(contributor.organization&.abbreviation)
+          return name if name.empty? || abbrev.empty?
+
+          "#{name} (#{abbrev})"
+        end
+
+        def item_kind
+          @kind || @style.kind_for(@model.type)
+        end
+
+        def person_completename(person)
+          localized(person.name&.completename)
+        end
+
+        def person_surname(person)
+          localized(person.name&.surname)
+        end
+
+        def person_given(person)
+          parts = Array(person.name&.forename).map do |f|
+            content = localized(f)
+            next content unless content.empty?
+            next initial(f.initial) if f.initial.to_s.length == 1
+
+            ""
+          end.reject(&:empty?)
+          sep = @style.scheme.name_form.initials_separator.to_s
+          return reinitials(localized(person.name&.formatted_initials)) if
+            parts.empty?
+          return given_with_first_full(parts, sep) if initials?
+
+          parts.join(" ")
+        end
+
+        # The document-history name form: the first forename cites in
+        # full, the rest as initials ("Milena S.")
+        def given_with_first_full(parts, sep)
+          initials = parts.map { |p| initial(p) }
+          return initials.join(sep) unless
+            @style.scheme.name_form.subsequent_initials
+
+          rest = parts.drop(1).map { |p| initial(p) }.join(sep)
+          rest.empty? ? parts.first : "#{parts.first}#{sep}#{rest}"
+        end
+
+        # Declared initials are a list in string form; rejoin them with
+        # the style's separator
+        def reinitials(raw)
+          sep = @style.scheme.name_form.initials_separator.to_s
+          dots = @style.scheme.name_form.initials_period
+          raw.split(/\s+/).reject(&:empty?).map { |i| dots ? i : i.delete(".") }
+            .join(sep)
+        end
+
+        def initial(name)
+          @style.scheme.name_form.initials_period ? "#{name[0]}." : name[0]
+        end
+
+        def initials?
+          @style.scheme.name_form.initials
+        end
+
+        def join_names(names)
+          # A style with no join word renders a plain serial list,
+          # separated per the locale (the comma, or the CJK 、)
+          if @i18n.label("and").empty? && names.size > 1
+            sep = @i18n.label("list_separator")
+            sep = ", " if sep == "list_separator"
+            return names.join(sep)
+          end
+
+          oxford = @i18n.label("oxford_comma")
+          if serial_list? && names.size > 1 && !oxford.empty?
+            return "#{names[0..-2].join(', ')}#{oxford} " \
+              "#{@i18n.label('and')} #{names.last}"
+          end
+
+          case names.size
+          when 0 then ""
+          when 1 then names.first
+          when 2 then names.join(" #{@i18n.label('and')} ")
+          else
+            "#{names[0..-2].join(', ')}#{oxford} " \
+            "#{@i18n.label('and')} #{names.last}"
+          end
+        end
+
+        # Serial list style: the oxford comma appears at every gap of a
+        # name list, including between two names
+        def serial_list?
+          @style.scheme.name_form.list_style == "serial"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Relaton
+  module Render
+    module Iso690
+      module Elements
+        # Date of access (ISO 690 clause 7.12): "[viewed: September 3,
+        # 2019]" for online resources consulted.
+        class Access < Element
+          def present?
+            !date_text.empty?
+          end
+
+          def render
+            "[#{@i18n.label('viewed')}: #{date_text}]"
+          end
+
+          private
+
+          def date_text
+            d = Array(@model.date).find { |x| x.type == "accessed" } or return ""
+            value = (d.at || d.from || d.to).to_s
+            parts = value.split("-")
+            case parts.size
+            when 3
+              date = ::Date.parse(value)
+              "#{month(date.month)} #{date.day}, #{date.year}"
+            when 2
+              "#{month(parts[1].to_i)} #{parts[0]}"
+            else
+              value
+            end
+          end
+
+          def month(num)
+            @i18n.label("month_#{num}")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      module Elements
+        # The authorizing body of a standard (the IETF RFC Series, the
+        # W3C Recommendation process): the organization carrying the
+        # authorizer role, cited after the status
+        class Authorizer < Element
+          def present?
+            !authorizer_name.empty?
+          end
+
+          def render
+            if (form = authorizer_form) && !form.empty?
+              return Template.new(form).evaluate(
+                "authorizer" => Template::Field[true, authorizer_name],
+              )
+            end
+
+            authorizer_name
+          end
+
+          # The kind's declared form for this slot: the first entry of
+          # the kind carrying one (a home variant may shadow the type)
+          def authorizer_form
+            kind = @style.kind_for(@model.type)
+            @style.per_type.find do |t|
+              t.type == kind && !t.authorizer.to_s.empty?
+            end&.authorizer
+          end
+
+          private
+
+          def authorizer_name
+            contributors("authorizer").map do |c|
+              Array(c.organization&.name).map { |n| localized(n) }.join(", ")
+            end.reject(&:empty?).first.to_s
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      module Elements
+        # The cited identifier with the item's status beside it and the
+        # list comma ("OGC 05-020r27 (Draft)," / "ISO 712,"): the comma
+        # stays with the identifier whichever side of the status it
+        # follows
+        class Citeid < Element
+          def present?
+            identifier_element.present?
+          end
+
+          def render
+            text = identifier_element.render
+            stage = status_element.present? ? status_element.render : ""
+            stage.empty? ? "#{text}," : "#{text}#{stage},"
+          end
+
+          private
+
+          def identifier_element
+            @identifier_element ||=
+              Identifier.new(@model, style: @style, i18n: @i18n, kind: @kind,
+                                    short: @short)
+          end
+
+          def status_element
+            @status_element ||=
+              Status.new(@model, style: @style, i18n: @i18n, kind: @kind,
+                                 short: @short)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      module Elements
+        # Component part within a host (ISO 690 clause 7.4): host title
+        # (emphasised), host editors, host edition, host place and
+        # publisher. Host data comes from the typed partOf/includedIn
+        # relation.
+        class ComponentPart < Element
+          HOST_RELATION_TYPES = %w[partOf includedIn].freeze
+
+          def present?
+            !host_title_text.empty?
+          end
+
+          def render
+            "#{lead}#{host_title}#{host_editors}#{host_edition}" \
+              "#{host_production}"
+          end
+
+          private
+
+          def lead
+            label = @i18n.label("in")
+            label.empty? ? "" : "#{label} "
+          end
+
+          def relation
+            Array(@model.relation).find do |r|
+              HOST_RELATION_TYPES.include?(r.type)
+            end
+          end
+
+          def host
+            relation&.bibitem
+          end
+
+          def host_title_text
+            return localized(relation&.description) if host.nil?
+
+            titles_in_lang(host.title).map { |t| localized(t) }
+              .join(" ").strip
+          end
+
+          def host_title
+            return "" if host_title_text.empty?
+
+            "#{@style.templates.title_open}#{host_title_text}" \
+              "#{@style.templates.title_close}"
+          end
+
+          def host_editors
+            eds = Array(host&.contributor).select { |c| has_role?(c, "editor") }
+            names = eds.each_with_index
+              .map { |c, i| host_person_name(c, first: i.zero?) }
+              .reject(&:empty?)
+            return "" if names.empty?
+
+            " (#{@i18n.label(eds.one? ? 'ed' : 'eds')} #{join_names(names)})"
+          end
+
+          # ISO 690 clause 7.2 host editors: the first name inverted
+          # (surname, initials), subsequent names in direct order, all in
+          # mixed case
+          def host_person_name(contributor, first:)
+            person = contributor.person or return ""
+
+            surname = person_surname(person)
+            given = person_given(person)
+            if first
+              [surname, given].reject(&:empty?).join(", ")
+            else
+              [given, surname].reject(&:empty?).join(" ")
+            end
+          end
+
+          def host_edition
+            return "" if host.nil?
+
+            edition = Edition.new(host, style: @style, i18n: @i18n,
+                                  kind: item_kind)
+            edition.present? ? ". #{edition.render}" : ""
+          end
+
+          def host_production
+            return "" if host.nil?
+
+            production = Production.new(host, style: @style, i18n: @i18n)
+            production.present? ? ". #{production.render}" : ""
+          end
+        end
+      end
+    end
+  end
+end