relaton 3.0.7 → 3.1.0

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

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      module Elements
+        # Name(s) of creator(s) (ISO 690 clause 7.2). The first creator is
+        # given inverted per the style's name form (SURNAME, forenames),
+        # subsequent creators in direct order (forenames SURNAME); name
+        # parts come from the typed model, never decomposed from a
+        # rendered string.
+        class Creator < Element
+          def present?
+            !creators.empty? || !fallback_name.empty?
+          end
+
+          def render
+            return plain_render if @short
+
+            joined = if (truncated = truncated_creators)
+                       truncated
+                     elsif creators.empty?
+                       fallback_name
+                     elsif (form = @style.templates.creators) && !form.empty?
+                       ::Relaton::Render::Iso690::Template.new(form).evaluate(
+                         "names" => Template::Field[true, join(names)],
+                       )
+                     else
+                       join(names)
+                     end
+            case role_placement
+            when "afterPeriod"
+              # the in-slot trailing space separates the (eds.) marker
+              # from the next element, which follows directly in the
+              # template; a lone editor is unmarked unless declared
+              if editors? && marked?
+                "#{period(joined)}#{role_space}#{role_parenthesis} "
+              else
+                "#{period(joined)} "
+              end
+            else
+              marker = editors? && marked? ? "#{role_space}#{role_parenthesis}" : ''
+              "#{joined}#{marker}"
+            end
+          end
+
+          # The short cite splits after the creators: they render as a
+          # plain join, without the wrap and sentence period (1.x
+          # short-cite templates carried no wrap)
+          def plain_render
+            marker = editors? && marked? ? "#{role_space}#{role_parenthesis}" : ''
+            "#{join(names)}#{marker}"
+          end
+
+          # The editor role marker's parentheses follow the locale
+          # (ASCII for Latin scripts, fullwidth for CJK)
+          def role_parenthesis
+            open = @i18n.punct_fetch("open-paren", "(")
+            close = @i18n.punct_fetch("close-paren", ")")
+            "#{open}#{role_word}#{close}"
+          end
+
+          # CJK cites the role marker tight against the name list
+          def role_space
+            @i18n.punct_fetch("marker-space", " ")
+          end
+
+          # The template-level role slot ("{{role}}"): the marker with
+          # its locale spacing, when the creators are all editors
+          def role_marker
+            editors? ? "#{role_space}#{role_parenthesis}" : ""
+          end
+
+          def role_placement
+            @style.scheme.name_form.role_placement || "glue"
+          end
+
+          def period(text)
+            text.end_with?(".") ? text : "#{text}."
+          end
+
+          def marked?
+            name_form.editors_marked &&
+              (creators.size > 1 || name_form.lone_editor_marked)
+          end
+
+          def role_word
+            @i18n.label(creators.one? ? "ed" : "eds")
+          end
+
+          # In-text (name-and-date) form: the principal creator only;
+          # at the style's et-al threshold the cite truncates
+          # ("Aluffi <em>et al.</em>")
+          def in_text
+            return in_text_etal if in_text_etal?
+
+            name = creators.first ? in_text_name(creators.first) : ""
+            etal? ? "#{name}#{etal_suffix}" : name
+          end
+
+          # The in-text cite truncates at its own threshold: at
+          # inTextEtalCount creators it shows the first
+          # inTextEtalDisplay surnames ("Aluffi <em>et al.</em>")
+          def in_text_etal
+            names = creators.first(name_form.in_text_etal_display)
+              .map { |c| in_text_name(c) }
+            "#{join(names)}#{etal_suffix}"
+          end
+
+          # The et-al suffix is the locale's label (roman by default; a
+          # pack's `others` label may carry its own presentation), joined
+          # per the style's list style — the serial comma before it is the
+          # MLA form ("Fielding, Roy, et al.")
+          def etal_suffix
+            sep = name_form.list_style == "serial" ? "," : ""
+            "#{sep} #{@i18n.label('others')}"
+          end
+
+          # The in-text cite names by surname alone (the 1.x
+          # authorcitetemplate), never by initials
+          def in_text_name(contributor)
+            person = contributor.person or return org_name(contributor)
+            complete = completename(person)
+            return complete unless complete.nil?
+
+            raw = surname(person).to_s
+            name_form.surname_upcase ? raw.upcase : raw
+          end
+
+          def in_text_etal?
+            count = name_form.in_text_etal_count
+            count.positive? && creators.size >= count
+          end
+
+          def etal?
+            count = name_form.etal_count
+            count.positive? && creators.size >= count
+          end
+
+          # The principal creator's given names, as the name form declares
+          def principal_given
+            principal = creators.first or return ""
+            person = principal.person or return ""
+            complete = completename(person)
+            return "" if complete
+
+            given_names(person)
+          end
+
+          private
+
+          def creators
+            @creators ||= begin
+              found = contributors("author")
+              found = contributors("editor") if found.empty?
+              found
+            end
+          end
+
+          # The declared creator fallback for items with no personal
+          # creators: the publishers' abbreviation or full name — all
+          # publishers cite, joined per the style's list style ("ISO and
+          # IEC")
+          def fallback_name
+            orgs = contributors("publisher")
+            name = case name_form.creator_fallback
+                   when "publisher_abbrev"
+                     orgs.map do |c|
+                       localized(c.organization&.abbreviation)
+                     end
+                   when "publisher_name"
+                     orgs.map do |c|
+                       localized(Array(c.organization&.name).first)
+                     end
+                   else
+                     []
+                   end
+            join_names(name.reject(&:empty?))
+          end
+
+          def names
+            creators.each_with_index
+              .map do |contributor, index|
+              format(contributor,
+                     first: index.zero?)
+            end
+          end
+
+          # The style's et-al truncation ("Aluffi, P., D. Anderson,
+          # M. Hering <em>et al.</em>"): at etalCount creators, the
+          # first etalDisplay names cite, comma-joined without the
+          # terminal and-join
+          def truncated_creators
+            count = name_form.etal_count
+            display = name_form.etal_display
+            return nil if count <= 0 || display <= 0 ||
+              creators.size < count
+
+            creators.first(display).each_with_index
+              .map do |contributor, index|
+              format(contributor, first: index.zero?)
+            end.join(", ") + etal_suffix
+          end
+
+          def format(contributor, first:)
+            person = contributor.person or return org_name(contributor)
+            name = completename_name(person, first: first) ||
+              personal_name(person, first: first)
+            name.empty? ? org_name(contributor) : name
+          end
+
+          def completename_name(person, first:)
+            complete = completename(person) or return nil
+            return complete unless name_form.completename_upcase
+
+            first ? @style.render_name(surname: complete, given: "") :
+              complete.upcase
+          end
+
+          def personal_name(person, first:)
+            surname = surname(person).to_s
+            given = given_names(person)
+            if (first || name_form.inverted_all) && !name_form.given_name_first
+              @style.render_name(surname: surname, given: given)
+            else
+              # the direct form initializes per the style's initials
+              # knob ("S. Payne" over "Sam Payne")
+              shown = name_form.subsequent_surname_upcase ? surname.upcase :
+                        surname
+              [person_given(person), shown].reject(&:empty?).join(" ")
+            end
+          end
+
+          def name_form
+            @style.scheme.name_form
+          end
+
+          def join(names)
+            join_names(names)
+          end
+
+          def editors?
+            !creators.empty? && creators.all? { |c| has_role?(c, "editor") }
+          end
+
+          def completename(person)
+            value = person_completename(person)
+            value.empty? ? nil : value
+          end
+
+          def surname(person)
+            value = person_surname(person)
+            value.empty? ? nil : value
+          end
+
+          def given_names(person)
+            person_given(person)
+          end
+
+          def org_name(contributor)
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      module Elements
+        # Edition and version (ISO 690 clause 7.6). The model numbers the
+        # edition through Edition#number (falling back to its content).
+        class Edition < Element
+          def present?
+            !raw.to_s.empty?
+          end
+
+          def render
+            return "#{@i18n.label('version')} #{raw}" unless word_edition?
+
+            # The exact worded forms first ("first edition", "第1版"),
+            # then the generic ordinal template, the cardinal last: a
+            # specific label outranks a template that would apply to
+            # any number
+            word = @i18n.label("edition_#{number}")
+            return word unless word == "edition_#{number}"
+
+            ordinal = locale_template("edition_ordinal", number)
+            return ordinal if ordinal
+
+            cardinal_form || "#{ordinalize(number)} #{@i18n.label('edition')}"
+          end
+
+          # The plain cardinal form ("edition 7")
+          def cardinal_form
+            locale_template("edition_cardinal", number) ||
+              locale_template("version_cardinal", number)
+          end
+
+          private
+
+          # A locale template carrying {{ var1 }} (optionally through
+          # the ordinal_word filter) populated with the edition number;
+          # a bare label (no placeholder) is not one
+          def locale_template(key, value)
+            raw = @i18n.label(key)
+            return nil if raw == key || raw !~ /\{{/
+
+            if raw.include?("ordinal_word")
+              word = @i18n.label("ordinal_word_#{value}")
+              word = ordinalize(value) if word == "ordinal_word_#{value}"
+              raw.gsub(/\{\{\s*var1[^}]*\}\}/, word)
+            else
+              raw.gsub("{{ var1 }}", value.to_s)
+            end
+          end
+
+          private
+
+          # Worded editions are document editions; online resources
+          # carry numbered builds rendered as versions. A standard is a
+          # document edition too (its report kind carries the clause 8.11
+          # fallback templates, but its numbered editions read as
+          # "Nth edition" — the TS contract renders them so).
+          def word_edition?
+            number.positive? &&
+              %w[monograph component_part serial_part report]
+                .include?(item_kind)
+          end
+
+          def raw
+            (@model.edition&.number || @model.edition&.content).to_s
+          end
+
+          def number
+            Integer(raw)
+          rescue ArgumentError, TypeError
+            0
+          end
+
+          def ordinalize(num)
+            "#{num}#{ordinal_suffix(num)}"
+          end
+
+          def ordinal_suffix(num)
+            case num % 100
+            when 11, 12, 13 then "th"
+            else
+              case num % 10
+              when 1 then "st"
+              when 2 then "nd"
+              when 3 then "rd"
+              else "th"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      module Elements
+        # Extent of the item (ISO 690 clause 7.11): page localities.
+        class Extent < Element
+          def present?
+            !render.empty?
+          end
+
+          def render
+            groups = [numeration, page_range].reject { |g| g.empty? }
+            groups.join(group_sep)
+          end
+
+          private
+
+          # An extent label is a template over its value: "vol. %" in
+          # the Latin pack, "巻%" / "%頁" in the CJK packs
+          def unit(type, value)
+            label = @i18n.label(type)
+            return "#{label} #{value}" unless label.include?("%")
+
+            label.gsub("%") { value }
+          end
+
+          def cjk?(label)
+            label.match?(/\p{Han}|\p{Hiragana}|\p{Katakana}/)
+          end
+
+          def group_sep
+            sep = @i18n.label("extent_group_separator")
+            return sep unless sep == "extent_group_separator"
+
+            cjk?(@i18n.label("page")) ? "、 " : ", "
+          end
+
+          def numeration
+            %w[volume issue].filter_map do |type|
+              loc = localities.find { |l| l.type == type }
+              next if loc.nil? || loc.reference_from.to_s.empty?
+
+              unit(type, loc.reference_from)
+            end.join(" ")
+          end
+
+          def page_range
+            loc = localities.find { |l| l.type == "page" } or return ""
+            from = loc.reference_from.to_s
+            to = loc.reference_to.to_s
+            if to.empty? || to == from
+              unit("page", from)
+            else
+              range = "#{from}#{@i18n.label('date_range')}#{to}"
+              unit("pages", range)
+            end
+          end
+
+          def localities
+            Array(@model.extent).flat_map do |e|
+              Array(e.locality) +
+                Array(e.locality_stack).flat_map { |s| Array(s.locality) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      module Elements
+        # Standard and persistent identifiers, rendered by kind
+        class Identifier < Element
+          INTERNAL_TYPES = %w[metanorma metanorma-ordinal metanorma-objid]
+            .freeze
+
+          def present?
+            !identifiers.empty?
+          end
+
+
+          def render
+            return "" if identifiers.empty?
+
+            ids = @style.templates.identifier_mode == "first" ?
+              [identifiers.first] : identifiers
+            ids.map { |d| render_id(d) }
+              .join(@i18n.punct_fetch("identifier_join", ". "))
+          end
+
+          # A flavor's identifier kinds subclass this element and
+          # override here
+          def render_id(docidentifier)
+            IdentifierKinds.render(docidentifier)
+          end
+
+          private
+
+          # Scoped identifiers (anchor, biblio-tag) are pipeline
+          # artefacts, not cited identifiers
+          def identifiers
+            Array(@model.docidentifier).reject do |d|
+              INTERNAL_TYPES.include?(d.type) ||
+                !d.scope.to_s.empty? || d.content.to_s.strip.empty?
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      module Elements
+        # Availability and location (ISO 690 clause 7.12): access location
+        # (URI) of the resource
+        class Location < Element
+          def present?
+            !uri.empty?
+          end
+
+          def render
+            text = uri
+            form = uri_form
+            # an access location cites its own label ("At: Library"); a
+            # uri carries the availability label
+            if @from_accesslocation
+              return "#{@i18n.label('at_url')} #{text}".strip
+            end
+
+            text = if form && !form.empty?
+                     ::Relaton::Render::Iso690::Template.new(form).evaluate(
+                       "uri" => Template::Field[!text.empty?, text],
+                     )
+                   else
+                     text
+                   end
+
+            label = @short ? "" : "#{@i18n.label('available_from')} "
+            "#{label}#{text}".strip
+          end
+
+          private
+
+          # The short cite renders the bare uri (1.x short templates),
+          # the reference the declared form
+          def uri_form
+            if @short
+              short_form = @style.templates.uri_short
+              return :bare if short_form.empty?
+
+              return short_form
+            end
+
+            @style.templates.uri
+          end
+
+          def uri
+            from_accesslocation =
+              Array(@model.accesslocation).map(&:to_s).reject(&:empty?)
+            unless from_accesslocation.empty?
+              @from_accesslocation = true
+              return from_accesslocation.first.to_s
+            end
+
+            uris = Array(@model.source).reject do |u|
+              u.content.to_s.strip.empty?
+            end
+            # the citation uri outranks the rest (1.x uri extraction)
+            preferred = uris.find { |u| u.type == "citation" } ||
+              uris.find { |u| u.type == "attachment" } ||
+              uris.find { |u| u.type == "src" } || uris.first
+            # the uri lands inside a markup attribute: escape it
+            require "cgi"
+            CGI.escapeHTML(preferred&.content.to_s)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      module Elements
+        # Medium designation (ISO 690 clause 7.5), bracketed per the
+        # standard's worked examples, e.g. "[online]"
+        class Medium < Element
+          def present?
+            !medium.empty?
+          end
+
+          def render
+            medium
+          end
+
+          private
+
+          def medium
+            genre = @model.medium&.genre.to_s
+            return genre.sub(/^\w/) { |c| c.upcase } unless genre.empty?
+
+            key = "medium_#{@model.type}"
+            label = @i18n.label(key)
+            label == key ? "" : label
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      module Elements
+        # Numeration within a series (ISO 690 clause 7.9): report numbers
+        class Numeration < Element
+          def present?
+            !docnumber.to_s.empty?
+          end
+
+          def render
+            "#{@i18n.label('report_no')} #{docnumber}"
+          end
+
+          private
+
+          def docnumber
+            @model.docnumber
+          end
+        end
+      end
+    end
+  end
+end