relaton 3.0.7 → 3.0.8

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      module Elements
+        # Production information: place and publisher (ISO 690 clause 7.8).
+        # Place comes from the model's typed city; publishers from
+        # organization contributors.
+        class Production < Element
+          def present?
+            !places.empty? || !publishers.empty? || no_place_declared?
+          end
+
+          def render
+            if (form = production_form) && !form.empty?
+              return Template.new(form).evaluate(
+                "production" => Template::Field[true, render_production],
+              )
+            end
+
+            render_production
+          end
+
+          def render_production
+            if publisher_first?
+              return no_place_production_publisher_first if places.empty? &&
+                no_place_declared?
+
+              return [publishers.join("; "), places.map { |p| cjk_place(p) }]
+                .reject(&:empty?).join(production_sep)
+            end
+
+            return no_place_production if places.empty? && no_place_declared?
+
+            [places.map { |p| cjk_place(p) }, publishers.join("; ")]
+              .reject(&:empty?).join(production_sep)
+          end
+
+          # A CJK locale's place names carry the CJK-Latin separator
+        # ("Cambridge、UK" over "Cambridge, UK")
+        def cjk_place(place)
+          sep = @i18n.punct_fetch("cjk-latin-separator", "")
+          sep.empty? ? place : place.gsub(", ", sep)
+        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 production_form
+          kind = @style.kind_for(@model.type)
+          @style.per_type.find do |t|
+            t.type == kind && !t.production.to_s.empty?
+          end&.production
+        end
+
+        def publisher_first?
+            @i18n.punct_fetch("production_order", "") == "publisher_first"
+          end
+
+          def production_sep
+            @i18n.punct_fetch("production_sep", ": ")
+          end
+
+          def no_place_production_publisher_first
+            label = @i18n.label("no_place")
+            return "" if label.empty? || label == "no_place"
+
+            pubs = publishers.join("; ")
+            pubs.empty? ? label : "#{pubs}, #{label}"
+          end
+
+          # The no-place placeholder keeps the production separator even
+          # when no publisher follows ("n.p.: n.d.")
+          def no_place_production
+            label = @i18n.label("no_place")
+            return "" if label.empty? || label == "no_place"
+
+            pubs = publishers.join("; ")
+            pubs.empty? ? "#{label}#{production_sep}".rstrip :
+              "#{label}#{production_sep}#{pubs}"
+          end
+
+          def no_place_declared?
+            @style.type_template_for(item_kind)&.no_place == true
+          end
+
+          private
+
+          def places
+            Array(@model.place).map do |p|
+              structured = [p.city.to_s, p.region.map(&:content),
+                            p.country.map(&:content)]
+                .flatten.reject { |c| c.strip.empty? }
+              if structured.empty? && !p.formatted_place.to_s.empty?
+                next p.formatted_place.to_s
+              end
+
+              structured.join(", ")
+            end.reject(&:empty?)
+          end
+
+          def publishers
+            contributors("publisher").map do |c|
+              Array(c.organization&.name).map { |n| localized(n) }.join(", ")
+            end.reject(&:empty?)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      module Elements
+        # Date of publication (ISO 690 clause 7.7). The relaton model
+        # provides typed date values (StringDate::Value#to_date); years
+        # come from the model, never from string manipulation. A from/to
+        # pair renders as a range (closed or open).
+        class PubDate < Element
+          def present?
+            !render.nil?
+          end
+
+          def render
+            range || year&.to_s
+          end
+
+          private
+
+          def publication_date
+            Array(@model.date).find(&:published) ||
+              Array(@model.date).find { |d| d.type.nil? } ||
+              Array(@model.date).find { |d| d.type == "created" } ||
+              Array(@model.date).find { |d| d.type == "issued" } ||
+              Array(@model.date).find { |d| d.type == "circulated" }
+          end
+
+          def publication_date_value
+            d = publication_date or return nil
+            d.from || d.at || d.to
+          end
+
+          def range
+            d = publication_date or return nil
+            dash = @i18n.label("date_range")
+            if d.from && d.to
+              fy = d.from.to_date.year
+              ty = d.to.to_date.year
+              return (fy == ty ? fy.to_s : "#{fy}#{dash}#{ty}")
+            end
+
+            # A from-only date is an open run ("1925–") for a
+            # continuing resource; a monograph's publication date
+            # cites the year bare ("2022") — the trailing dash would
+            # leak into the terminator otherwise
+            if d.from && %w[continuing serial_part online webdoc]
+                .include?(item_kind)
+              "#{d.from.to_date.year}#{dash}"
+            end
+          end
+
+          def year
+            publication_date_value.to_date.year
+          rescue ArgumentError, TypeError, NoMethodError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      module Elements
+        # Series title and number (ISO 690 clause 7.10)
+        class Series < Element
+          def present?
+            !series_title.empty?
+          end
+
+          def render
+            if (form = series_form) && !form.empty?
+              return ::Relaton::Render::Iso690::Template.new(form).evaluate(
+                "seriestitle" => Template::Field[!series_title.empty?,
+                                                 series_title],
+                "seriesnumber" => Template::Field[!number.empty?, number],
+                "seriesrun" => Template::Field[!run.empty?, run],
+              )
+            end
+
+            base = "#{@style.templates.title_open}#{series_title}" \
+                   "#{@style.templates.title_close}"
+            if number.empty?
+              base
+            else
+              # an empty series_no label joins on the space alone (the
+              # CJK form: "Series 472")
+              label = @i18n.label("series_no")
+              label.empty? ? "#{base} #{number}" :
+                "#{base}, #{label} #{number}"
+            end
+          end
+
+          private
+
+          def series
+            Array(@model.series).first
+          end
+
+          def series_title
+            titles_in_lang(series&.title).map { |t| localized(t) }
+              .join(" ").strip
+          end
+
+          def number
+            series&.number.to_s
+          end
+
+          def run
+            series&.run.to_s
+          end
+
+          # The style's series form for this item's resource kind, falling
+          # back to the style-wide form
+          def series_form
+            variant = @style.per_type
+              .find { |t| t.type == @style.kind_for(@model.type) }
+            variant&.series || @style.templates.series
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      module Elements
+        # Physical size (ISO 690 clause 7.5, area): the model's typed
+        # values render as "N unit" through the language pack; untyped
+        # values pass through as written.
+        class Size < Element
+          def present?
+            !values.empty?
+          end
+
+          def render
+            values.map { |v| render_value(v) }.join(", ")
+          end
+
+          private
+
+          def values
+            Array(@model.size&.value)
+          end
+
+          def render_value(value)
+            content = value.is_a?(String) ? value : value.content.to_s
+            return content if content.empty? || value.is_a?(String)
+
+            type = value.is_a?(Hash) ? value[:type] : value.type
+            unit = type && @i18n.label("size_#{type}")
+            return content if unit.nil? || unit == "size_#{type}"
+
+            # A %-template places the value at its % (the extent
+            # precedent: "% vol." cites "1 vol."); the value/unit glue
+            # is otherwise locale-declared (CJK cites tight, "巻1"
+            # over "vol. 1")
+            return unit.gsub("%", content) if unit.include?("%")
+
+            "#{unit}#{@i18n.punct_fetch('size-join', ' ')}#{content}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      module Elements
+        # The item's status stage, capitalized, parenthesized beside
+        # the identifier ("OGC 05-020r27 (Draft)"); published statuses
+        # are not cited
+        class Status < Element
+          def present?
+            !stage.empty? &&
+              !%w[published retired].include?(stage.downcase)
+          end
+
+          def render
+            " (#{stage})"
+          end
+
+          private
+
+          def stage
+            raw = @model.status&.stage&.content.to_s
+            raw.empty? ? "" : raw.sub(/^\w/) { |c| c.upcase }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      module Elements
+        # Issuing body or status of a standard (ISO 690 clause 8.9): the
+        # publisher or authorizer organization, falling back to the
+        # capitalized status stage.
+        class Stddoc < Element
+          def present?
+            !body.empty?
+          end
+
+          def render
+            body
+          end
+
+          private
+
+          def body
+            orgs = %w[publisher authorizer].flat_map { |role|
+              contributors(role).map { |c| org_plain(c) }
+            }.reject(&:empty?)
+            return orgs.join("; ") unless orgs.empty?
+
+            stage = @model.status&.stage&.content.to_s
+            stage.empty? ? "" : stage.sub(/^\w/) { |c| c.upcase }
+          end
+
+          # Issuing bodies render in mixed case, unlike creator organs
+          def org_plain(contributor)
+            Array(contributor.organization&.name)
+              .map { |n| localized(n) }.join(", ")
+          end
+        end
+      end
+    end
+  end
+end

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