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

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,30 @@
+# 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
+            authorizer_name
+          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,99 @@
+# 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 @style.scheme.name_form.inverted_all
+              @style.render_name(surname: surname, given: given)
+            elsif 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

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

@@ -0,0 +1,258 @@
+# 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} <em>et al.</em>" : 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)} <em>et al.</em>"
+          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(", ") + " <em>et al.</em>"
+          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