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

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

@@ -0,0 +1,92 @@
+# 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 worded forms first ("First edition", "第N版" via the
+            # ordinal template), the cardinal last
+            ordinal = locale_template("edition_ordinal", number)
+            return ordinal if ordinal
+
+            word = @i18n.label("edition_#{number}")
+            return word unless word == "edition_#{number}"
+
+            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
+          def word_edition?
+            number.positive? &&
+              %w[monograph component_part serial_part]
+                .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.sub("%", 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

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

@@ -0,0 +1,92 @@
+# 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 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
+
+        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,56 @@
+# 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
+              fy == ty ? fy.to_s : "#{fy}#{dash}#{ty}"
+            elsif d.from
+              "#{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,41 @@
+# 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}"
+
+            # The value/unit glue is locale-declared (CJK cites tight,
+            # "巻1" over "vol. 1")
+            "#{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