relaton 3.0.6 → 3.0.8

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      module Rules
+        # The JIS rule set, moved verbatim from the metanorma-jis
+        # flavor's JisElements: the host-title-first component part
+        # (with the 1.x orphaned close paren), the host-series
+        # fallback, and the book-family extent. Select from pack data:
+        #   rules: { component_part: jis_component_part, ... }
+        module Jis
+          # The host of a part citation, 1.x parity: the host title,
+          # then the host's principal creator, closed by a paren the
+          # 1.x cleanup had orphaned when the host role came out empty
+          # ("Collected Essays UNICEF)")
+          class JisComponentPart < Elements::ComponentPart
+            def render
+              return "" if host_title_text.empty?
+
+              "#{host_title_text} #{host_creators}#{close_paren}".strip
+            end
+
+            private
+
+            def host_creators
+              author = Array(host&.contributor)
+                .find { |c| has_role?(c, "author") } or return ""
+
+              person = author.person
+              if person.nil?
+                Array(author.organization&.name).map { |n| localized(n) }
+                  .reject(&:empty?).join(", ")
+              else
+                host_person_name(author, first: true)
+              end
+            end
+
+            def close_paren
+              @i18n.punct_fetch("close-paren", ")")
+            end
+          end
+
+          # A part cites its host's series when it carries none of its
+          # own (the 1.x series fallback to the host document)
+          class JisSeries < Elements::Series
+            private
+
+            def series
+              super || Array(host_relation&.bibitem&.series).first
+            end
+
+            def host_relation
+              Array(@model.relation).find do |r|
+                Elements::ComponentPart::HOST_RELATION_TYPES.include?(r.type)
+              end
+            end
+          end
+
+          # The book-family extent carries the volume and the page
+          # only, and repeated localities of one type collapse to the
+          # last declared (the 1.x per-type merge)
+          class JisExtent < Elements::Extent
+            def render
+              return super unless book_family?
+
+              [volume_part, page_part].reject(&:empty?).join(" ")
+            end
+
+            private
+
+            def book_family?
+              %w[book inbook incollection inproceedings proceedings]
+                .include?(@model.type.to_s)
+            end
+
+            def volume_part
+              loc = pick("volume") or return ""
+              loc.reference_from.to_s.empty? ? "" :
+                unit("volume", loc.reference_from)
+            end
+
+            def page_part
+              loc = pick("page") or return ""
+              from = loc.reference_from.to_s
+              to = loc.reference_to.to_s
+              if to.empty? || to == from
+                unit("page", from)
+              else
+                unit("pages", "#{from}#{@i18n.label('date_range')}#{to}")
+              end
+            end
+
+            # The last locality of a type wins (the 1.x merge)
+            def pick(type)
+              localities.reverse.find { |l| l.type == type }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,384 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Render
+    module Iso690
+      module Rules
+        # The NIST rule set, moved verbatim from the metanorma-nist
+        # flavor's NistElements: the corporate creator forms, the
+        # series derivation from nist-long identifiers, the draft
+        # stage forms, the identifier order, and the component-part
+        # host citation. Select from pack data:
+        #   rules: { creator: nist_series_publisher, ... }
+        module Nist
+          NIST_AND_ABBREV =
+            ["NIST", "National Institute of Standards and Technology"].freeze
+
+          STAGE_PRINT = {
+            "draft-internal" => "Internal Draft",
+            "draft-wip" => "Work-in-Progress Draft",
+            "draft-prelim" => "Preliminary Draft",
+            "draft-public" => "Public Draft",
+            "draft-approval" => "Approval Draft",
+            "final" => "Final",
+            "final-review" => "Under Review",
+          }.freeze
+
+          FIPS_PUBLISHER = "U.S. Department of Commerce, Washington, D.C."
+          NIST_PUBLISHER = "National Institute of Standards and Technology, " \
+                           "Gaithersburg, MD"
+
+          HOST_RELATION_TYPES = %w[partOf includedIn].freeze
+
+          # The partOf/includedIn host and its publication year: shared
+          # by the component part and the host-date fallback of the
+          # date element
+          module HostDate
+            def relation_host
+              Array(@model.relation).find do |r|
+                HOST_RELATION_TYPES.include?(r.type)
+              end&.bibitem
+            end
+
+            def host_date_year
+              h = relation_host or return ""
+              d = Array(h.date).find(&:published) ||
+                  Array(h.date).find { |x| x.type.nil? } ||
+                  Array(h.date).find { |x| x.type == "issued" } ||
+                  Array(h.date).first or return ""
+              v = d.at || d.from || d.to or return ""
+              begin
+                v.to_date.year.to_s
+              rescue ArgumentError, TypeError
+                v.to_s[/\d{4}/].to_s
+              end
+            end
+          end
+
+          # NIST-aware element base: NIST Standard Reference documents
+          # are detected by identifier type or publisher
+          class Base < Element
+            def present?
+              !render.to_s.empty?
+            end
+
+            private
+
+            def nist?
+              return true if Array(@model.docidentifier).any? do |d|
+                d.type.to_s.start_with?("NIST")
+              end
+
+              Array(@model.contributor).select { |c| has_role?(c, "publisher") }
+                .any? do |c|
+                org = c.organization or next false
+
+                Array(org.name).any? { |n| NIST_AND_ABBREV.include?(n.content) } ||
+                  org.abbreviation&.content == "NIST"
+              end
+            end
+
+            def series_title
+              Array(@model.series).first&.title&.first&.content.to_s
+            end
+          end
+
+          # The series publisher block, parenthesized, after the title
+          class NistPublisher < Base
+            def render
+              if series_title == "NIST Federal Information Processing Standards"
+                return " (#{FIPS_PUBLISHER})"
+              end
+
+              nist? ? " (#{NIST_PUBLISHER})" : ""
+            end
+          end
+
+          # The NIST draft form ("Draft (Third Public Draft)")
+          class NistDraft < Base
+            def render
+              stage = @model.status&.stage&.content.to_s
+              return "" unless stage.start_with?("draft") && nist?
+
+              "Draft (#{iteration(stage)} #{STAGE_PRINT.fetch(stage, stage)})"
+            end
+
+            private
+
+            def iteration(stage)
+              iter = @model.status&.iteration.to_s
+              return "Initial" if iter.empty? || iter == "1"
+              return "Final" if iter.casecmp("final").zero?
+
+              spellout_ordinal(iter.to_i)
+            end
+
+            # The language packs carry ordinal word labels; beyond
+            # their reach the numeric suffix form carries the value
+            def spellout_ordinal(num)
+              word = @i18n.label("ordinal_word_#{num}")
+              return word.capitalize unless word == "ordinal_word_#{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
+
+          # The NIST series form ("NIST Special Publication (SP)
+          # 800-116 Rev. 1"). A series carrying a formattedref renders
+          # it verbatim; the number joins the partnumber ("800-116.1"),
+          # and the edition carries the revision. NIST documents
+          # without a series element derive it from the nist-long
+          # identifier
+          class NistSeries < Base
+            def render
+              s = Array(@model.series).first
+              return derived_series unless s
+
+              formatted = localized(s.formattedref)
+              return formatted unless formatted.empty?
+
+              title = localized(Array(s.title).first)
+              return "" if title.empty?
+
+              [title, parens(s), number(s)].reject(&:empty?).join(" ")
+            end
+
+            private
+
+            def derived_series
+              long = Array(@model.docidentifier).find do |d|
+                d.type == "nist-long"
+              end&.content.to_s
+              return "" if long.empty?
+
+              title = long[/\A(NIST [A-Za-z ]+?) \d/, 1] || ""
+              return "" if title.empty?
+
+              [title, parens_derived(long), number_derived(long)]
+                .reject(&:empty?).join(" ")
+            end
+
+            def parens_derived(long)
+              # strip the NIST sigla before the whitespace strip: the
+              # 1.x order left a bare "NIST" parenthesized
+              abbr = long[/\A[A-Z.]+ /, 0].to_s.sub(/\ANIST /, "").strip
+              abbr.empty? ? "" : "(#{abbr})"
+            end
+
+            def number_derived(long)
+              num = long[/\A[NISTa-z. ]*([0-9][0-9A-Za-z.-]*)/, 1].to_s
+              num.empty? ? num : with_revision(num)
+            end
+
+            def parens(s)
+              abbr = localized(s.abbreviation).sub(/\ANIST /, "")
+              abbr.empty? ? "" : "(#{abbr})"
+            end
+
+            def number(s)
+              num = s.number.to_s
+              unless s.partnumber.to_s.empty?
+                num = num.empty? ? s.partnumber.to_s : "#{num}.#{s.partnumber}"
+              end
+              num = @model.docnumber.to_s if num.empty? && nist?
+              num.empty? ? num : with_revision(num)
+            end
+
+            def with_revision(num)
+              rev = @model.edition&.content.to_s.sub(/\ARevision /, "")
+              rev.empty? ? num : "#{num} Rev. #{rev}"
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+module Relaton
+  module Render
+    module Iso690
+      module Rules
+        module Nist
+          # The NIST identifier order: the authoritative identifiers
+          # (ISO, IEC, ...) before the kind-rendered ISBN/DOI/ISSN
+          # group; NIST documents cite the NIST identifier alone (the
+          # biblio tag)
+          class NistIdentifier < Elements::Identifier
+            OTHER_TYPES = %w[ISBN ISSN DOI].freeze
+
+            def render
+              return "" if nist?
+
+              auth, other = unscoped_ids.partition do |d|
+                !OTHER_TYPES.include?(d.type)
+              end
+              (auth + other).map { |d| render_id(d) }.reject(&:empty?)
+                .join(". ")
+            end
+
+            private
+
+            def nist?
+              Array(@model.docidentifier).any? do |d|
+                d.type.to_s.start_with?("NIST")
+              end || Array(@model.contributor).any? do |c|
+                next false unless has_role?(c, "publisher")
+
+                org = c.organization or next false
+
+                Array(org.name).any? { |n| NIST_AND_ABBREV.include?(n.content) } ||
+                  org.abbreviation&.content == "NIST"
+              end
+            end
+
+            def unscoped_ids
+              Array(@model.docidentifier).reject do |d|
+                Elements::Identifier::INTERNAL_TYPES.include?(d.type) ||
+                  !d.scope.to_s.empty? || d.content.to_s.strip.empty?
+              end
+            end
+
+            # The NIST ISBN and ISSN kinds cite the kind label with a
+            # colon
+            def render_id(docidentifier)
+              return "#{docidentifier.type}: #{docidentifier.content}" if
+                %w[ISBN ISSN].include?(docidentifier.type)
+
+              super
+            end
+          end
+
+          # The NIST component-part order: the host editors before the
+          # host title, the host date after the production
+          # ("In: Pellegrini AD, Smith PK (Eds.) <em>The nature of
+          # play</em> (New York, NY: Guilford Press), 2005")
+          class NistComponentPart < Elements::ComponentPart
+            include HostDate
+
+            def render
+              h = relation_host or return ""
+              out = +"#{lead}#{host_names(h)}"
+              eds = host_editors(h)
+              out += " (#{@i18n.label(eds.one? ? "ed" : "eds")})" unless
+                eds.empty?
+              out += " #{host_title}" unless host_title_text.empty?
+              production = host_production_text(h)
+              out += " (#{production})" unless production.empty?
+              date = host_date_year
+              out += ", #{date}" unless date.empty?
+              out
+            end
+
+            private
+
+            def host_editors(h)
+              Array(h.contributor).select { |c| has_role?(c, "editor") }
+            end
+
+            def host_names(h)
+              names = host_editors(h).map { |c|
+                person = c.person or next ""
+
+                [person_surname(person), person_given(person)].reject(&:empty?)
+                  .join(" ")
+              }.reject(&:empty?)
+              join_names(names)
+            end
+
+            def host_production_text(h)
+              Elements::Production.new(h, style: @style, i18n: @i18n)
+                .render.to_s
+            end
+          end
+
+          # A component part with no date of its own cites the host's
+          class NistDate < Elements::PubDate
+            include HostDate
+
+            def render
+              text = super.to_s
+              text.empty? ? host_date_year : text
+            end
+          end
+
+          # The series-position date segment of the 1.x templates: the
+          # date carries its own leading comma ("<series>, 2018
+          # (updated November 2018)"), so an absent date removes the
+          # comma with it
+          class NistSerialDate < Base
+            def render
+              text = pub_date or return ""
+
+              ", #{text}#{updated_date}"
+            end
+
+            private
+
+            def pub_date
+              t = Elements::PubDate.new(@model, style: @style, i18n: @i18n)
+                .render.to_s
+              t.empty? ? nil : t
+            end
+
+            def updated_date
+              Elements::Updated.new(@model, style: @style, i18n: @i18n).render
+            end
+          end
+
+          # The FIPS creator form: the series names the corporate
+          # creator; standards without personal creators cite their
+          # publisher's name, monographs cite nothing (their "(n.d.)"
+          # comes from the perType fallback)
+          class NistCreator < Elements::Creator
+            def render
+              return fips_creator if fips_series?
+
+              super
+            end
+
+            def plain_render
+              return fips_creator if fips_series?
+
+              super
+            end
+
+            private
+
+            def fallback_name
+              return "" if %w[monograph continuing component_part]
+                .include?(Kinds.kind_for(@model.type))
+
+              publishers = contributors("publisher").filter_map do |c|
+                localized(Array(c.organization&.name).first)
+              end
+              publishers.reject(&:empty?).first.to_s
+            end
+
+            def fips_series?
+              Array(@model.series).first&.title&.first&.content ==
+                "NIST Federal Information Processing Standards"
+            end
+
+            def fips_creator
+              "National Institute of Standards and Technology"
+            end
+          end
+        end
+      end
+    end
+  end
+end