relaton-render 3.0.0.pre.alpha.17 → 3.0.0.pre.alpha.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 27e7e4b11e894ed7e6b848e0f4273dcb7db37ee2a32cc568b0b3b0b8424e2b1c
-  data.tar.gz: dd172b22c08947cf84fbb59d2526f4b95c6eb3db8a4c5a70ac16a403b64b67e5
+  metadata.gz: 14efa687d6e0316dd88f104203593084e6eefc7e16f7d7f42729f2c4c8e79ffb
+  data.tar.gz: ef2d1156dba8ad76bec04286e4748d05940692bb74ca5d7b2eb1a368425caa47
 SHA512:
-  metadata.gz: a5b8e6ac52e30a6e4f2250272c6c0ff09adcb83c26f147947b8df761e76e9492f45c2c6d3a3e37c8764c217a14a4e40af679c910f8c97266135309bc2fb7ddc5
-  data.tar.gz: 87fe7ab71691b69d007e00c9d18bd55bf53680a93df98d77d8cc7d938e2603df26d6498a052c3fcbff3d599241dfd131a769ce284374a30e99e322717dc0ce80
+  metadata.gz: eed19567e724a4103caca36f279df1dd559e7b9f1b495e51ee082c35b06b39b2440de8603815f443a9f29f36a962c59237814bdfa627e6f4812b9a4132268223
+  data.tar.gz: b67866542a100599e55a2107889b2a5a5f994113a62e40dde8a32e2e7da5fbc5f4cc38e03c55a3edb16bb1f3b934587490b9f21551aaaf708291da5435f347b9

data/lib/relaton/render/general.rb

@@ -32,9 +32,24 @@ module Relaton
         # A flavor names its own CitationStyle instance (name or YAML path)
         options[:style] and renderer_opts[:style] = options[:style]
         @renderer = Iso690::Renderer.new(**renderer_opts)
+        @renderer_opts = renderer_opts
+        @renderers_by_lang = {}
         warn_general_config if options[:config]
       end
 
+      # A collection's items may each declare their own language; the
+      # renderer localizes by language, so a reference renders in its
+      # own language within a document of another (the 1.x plateau
+      # per-reference behaviour)
+      def renderer_for(lang)
+        return @renderer if lang.nil? || lang == @lang
+
+        @renderers_by_lang[lang] ||= Iso690::Renderer.new(
+          **@renderer_opts.merge(lang: lang,
+                                 script: %w(ja ko zh).include?(lang) ? nil : "Latn")
+        )
+      end
+
       def render(model, embedded: false, **opts)
         model = to_model(model)
         text =
@@ -57,15 +72,20 @@ module Relaton
         items = facade_bibitems(bib) or return nil
         disambiguators = date_disambiguators(items)
         items.each_with_object({}).with_index do |(item, m), i|
+          renderer = renderer_for(Array(item.language).first)
           ref = begin
-            @renderer.render(item, disambiguator: disambiguators[item.id])
+            renderer.render(item, disambiguator: disambiguators[item.id])
           rescue ::Relaton::Render::Unrenderable
             next
           end
           m[item.id] = {
             id: item.id, ord: i,
+            author: renderer.in_text_author(item),
             formattedref: terminate_reference(ref, item),
-            citation: citation_renderings(item, ref),
+            citation: citation_renderings(item, ref, renderer,
+                                          type: type,
+                                          disambiguator:
+                                            disambiguators[item.id]),
           }
         end
       end
@@ -116,10 +136,14 @@ module Relaton
         "#{ref}."
       end
 
-      def citation_renderings(item, ref)
-        short = @renderer.citation(item)
+      # The style-keyed capsule ("citation" => { author_date: "..." })
+      # is what isodoc's styled erefs consume (their style attribute
+      # names the key)
+      def citation_renderings(item, ref, renderer, type: "author-date",
+                              disambiguator: nil)
+        short = renderer.citation(item)
         short = if short.empty?
-                  @renderer.render_short(item, FIRST_DELIM)
+                  renderer.render_short(item, FIRST_DELIM)
                 else
                   short
                 end
@@ -128,6 +152,11 @@ module Relaton
           full: ref,
           default: item.docidentifier.first&.content.to_s,
           short: short,
+          author_date: renderer.author_date_citation(
+            item, disambiguator: disambiguator,
+          ),
+          author: renderer.in_text_author(item),
+          title: renderer.title_citation(item),
         }
       end
 

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

@@ -73,14 +73,37 @@ module Relaton
           # at the style's et-al threshold the cite truncates
           # ("Aluffi <em>et al.</em>")
           def in_text
-            principal = creators.first or return ""
-            person = principal.person or return org_name(principal)
-            raw = surname(person).to_s
-            surname = name_form.surname_upcase ? raw.upcase : raw
-            name = completename(person) || surname || ""
+            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

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

@@ -52,7 +52,7 @@ module Relaton
           # back to the style-wide form
           def series_form
             variant = @style.per_type
-              .find { |t| t.type == Kinds.kind_for(@model.type) }
+              .find { |t| t.type == @style.kind_for(@model.type) }
             variant&.series || @style.templates.series
           end
         end

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

@@ -11,11 +11,17 @@ module Relaton
             !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(Kinds.kind_for(@model.type)))
+               (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])
@@ -31,7 +37,7 @@ module Relaton
           # serial carries the emphasis
           def analytic?
             %w[component_part serial_part]
-              .include?(Kinds.kind_for(@model.type))
+              .include?(@style.kind_for(@model.type))
           end
 
           # A typed main title wins; an untyped title is main by

data/lib/relaton/render/iso690/renderer.rb

@@ -82,6 +82,23 @@ module Relaton
                          elements: @elements).in_text
         end
 
+        # The author-date in-text capsule ("Aluffi <em>et al.</em>
+        # 2022a"): the in-text creator and the disambiguated date
+        def author_date_citation(model, disambiguator: nil)
+          f = Fields.new(model, style: @style, i18n: @i18n,
+                         disambiguator: disambiguator,
+                         elements: @elements).to_h
+          [in_text_author(model), f["disambiguateddate"].text]
+            .reject(&:empty?).join(" ")
+        end
+
+        # The title citation ("{{ title }}" in the 1.x citetemplate):
+        # the title element's plain form, no style markers
+        def title_citation(model)
+          Elements.build(:title, model, style: @style, i18n: @i18n,
+                         elements: @elements).plain
+        end
+
         # The in-text author key (the principal creator's surname, as
         # the citation renders it): the batch disambiguation groups by
         # it

data/lib/relaton/render/iso690/style/name_form.rb

@@ -46,6 +46,13 @@ module Relaton
           # first etalDisplay names with "et al." (0 disables)
           attribute :etal_count, :integer, default: 0
           attribute :etal_display, :integer, default: 0
+          # The in-text cite truncates separately from the creator
+          # list: at this many creators it shows the first
+          # inTextEtalDisplay names with "et al." (0 disables; IEEE
+          # cites 3+ as "Aluffi et al." while listing 6 in the
+          # bibliography)
+          attribute :in_text_etal_count, :integer, default: 0
+          attribute :in_text_etal_display, :integer, default: 1
           # Editor lists carry the role marker ("(Eds.)")
           attribute :editors_marked, :boolean, default: -> { true }
 
@@ -65,6 +72,8 @@ module Relaton
             map "subsequentSurnameUpcase", to: :subsequent_surname_upcase
             map "etalCount", to: :etal_count
             map "etalDisplay", to: :etal_display
+            map "inTextEtalCount", to: :in_text_etal_count
+            map "inTextEtalDisplay", to: :in_text_etal_display
             map "editorsMarked", to: :editors_marked
           end
         end

data/lib/relaton/render/iso690/template.rb

@@ -102,15 +102,25 @@ module Relaton
           end
         end
 
-        # A literal bridges two present elements when at least one
-        # present element stands on each side of it; a leading literal
-        # (no slot precedes it) attaches to the first slot, emitting
-        # only when that slot is present
+        # A literal is the trailing separator of the element that
+        # precedes it: it renders when that element renders and a
+        # later element renders, and it is the FIRST literal of its
+        # gap (the 1.x segment join — absent elements between two
+        # present ones leave the single separator that follows the
+        # earlier present element; an absent slot directly before a
+        # present one, as "{{date}}{{disambiguator}}, {{access}}",
+        # does not swallow it). A leading literal (no slot precedes
+        # it) attaches to the first slot, emitting only when that
+        # slot is present.
         def bridged?(index, present)
           first_slot = @chunks.index { |(kind, _)| kind == :slot }
           return present.include?(first_slot) if index < first_slot
 
-          present.any? { |i| i < index } && present.any? { |i| i > index }
+          left = present.select { |i| i < index }.max
+          left && present.any? { |i| i > index } &&
+            !@chunks[(left + 1)...index].any? do |(kind, _)|
+              kind == :text
+            end
         end
 
         # A template's paired literal ("({{production}})") closes even

data/lib/relaton/render/version.rb

@@ -1,5 +1,5 @@
 module Relaton
   module Render
-    VERSION = "3.0.0.pre.alpha.17".freeze
+    VERSION = "3.0.0.pre.alpha.19".freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: relaton-render
 version: !ruby/object:Gem::Version
-  version: 3.0.0.pre.alpha.17
+  version: 3.0.0.pre.alpha.19
 platform: ruby
 authors:
 - Ribose Inc.