relaton-render 1.4.0.pre.alpha.3 → 3.0.0.pre.alpha.1

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

@@ -0,0 +1,64 @@
+module Relaton
+  module Render
+    module Legacy
+      # Deep key transforms the 1.x templates rely on. Copied from the
+      # deprecated metanorma-utils implementation so this gem carries no
+      # metanorma dependency; method names match so a loaded
+      # metanorma-utils simply overrides these.
+      module HashCompat
+        def stringify_all_keys
+          result = {}
+          each do |k, v|
+            result[k.to_s] = case v
+                             when ::Hash, ::Array
+                               v.stringify_all_keys
+                             else
+                               v
+                             end
+          end
+          result
+        end
+
+        def symbolize_all_keys
+          result = {}
+          each do |k, v|
+            result[k.to_sym] = case v
+                               when ::Hash, ::Array
+                                 v.symbolize_all_keys
+                               else
+                                 v
+                               end
+          end
+          result
+        end
+      end
+
+      module ArrayCompat
+        def stringify_all_keys
+          map do |v|
+            case v
+            when ::Hash, ::Array
+              v.stringify_all_keys
+            else
+              v
+            end
+          end
+        end
+
+        def symbolize_all_keys
+          map do |v|
+            case v
+            when ::Hash, ::Array
+              v.symbolize_all_keys
+            else
+              v
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+Hash.include Relaton::Render::Legacy::HashCompat
+Array.include Relaton::Render::Legacy::ArrayCompat

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

@@ -0,0 +1,48 @@
+module Relaton
+  module Render
+    module Template
+      module CustomFilters
+        def capitalize_first(words)
+          words.nil? and return nil
+          # Split while preserving delimiters (spaces/underscores) and extracting XML tags
+          ret = words.split(/(<[^>]+>|[ _])/).reject(&:empty?)
+          # Find and capitalize the first element that is not a delimiter or XML tag
+          ret.each do |element|
+            element.match?(/^[ _]$/) || element.match?(/^<[^>]+>$/) and next
+            element.capitalize!
+            break
+          end
+          # Join with empty string since delimiters are preserved
+          ret.join.sub(/^[ _]+/, "").sub(/[ _]+$/, "")
+        end
+
+        def selective_upcase(text)
+          text.nil? and return nil
+          # Split to extract both +++...+++ sections and XML tags
+          text.split(/(\+\+\+[^+]+?\+\+\+|<[^<>]+>)/).map do |n|
+            if m = /^\+\+\+(.+)\+\+\+$/.match(n)
+              m[1] # Keep content inside +++ unchanged
+            elsif n.match?(/^<[^>]+>$/)
+              n # Keep XML tags unchanged
+            else n.upcase # Upcase everything else
+            end
+          end.join
+        end
+
+        def selective_tag(text, tag)
+          return nil if text.nil?
+
+          ret = text.split(/(\+\+\+[^+]+?\+\+\+)/)
+          ret.map do |n|
+            if m = /^\+\+\+(.+)\+\+\+$/.match(n)
+              m[1]
+            else
+              closetag = tag.sub(/^</, "</")
+              "#{tag}#{n}#{closetag}"
+            end
+          end.join
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+module Relaton
+  module Render
+    module Template
+      class Series < General
+      end
+
+      class Extent < General
+        def template_select(hash)
+          @template[hash[:type].to_sym]
+        end
+      end
+
+      class Size < General
+        def template_select(hash)
+          @template[hash[:type].to_sym]
+        end
+      end
+
+      class Name < General
+        def initialize(opt = {})
+          @etal_count = opt[:template]["etal_count"]
+          @etal_display = opt[:template]["etal_display"] || @etal_count
+          opt[:template].delete("etal_count")
+          opt[:template].delete("etal_display")
+          super
+        end
+
+        def template_select(names)
+          return nil if names.nil? || names.empty?
+
+          case names[:surname].size
+          when 1 then @template[:one]
+          when 2 then @template[:two]
+          when 3 then @template[:more]
+          else template_select_etal(names)
+          end
+        end
+
+        def template_select_etal(names)
+          if @etal_count && names[:surname].size > @etal_count
+            expand_nametemplate(@template_raw[:etal], @etal_display)
+          else
+            expand_nametemplate(@template_raw[:more], names[:surname].size)
+          end
+        end
+
+        # assumes that template contains, consecutively and not interleaved,
+        # ...[0], ...[1], ...[2]
+        def expand_nametemplate(template, size)
+          t = nametemplate_split(template)
+          mid = (1..size - 2).each_with_object([]) do |i, m|
+            m << t[1].gsub("[1]", "[#{i}]")
+          end
+          t[1] = mid.join
+          t[2].gsub!(/\[\d+\]/, "[#{size - 1}]")
+          template_process(combine_nametemplate(t, size))
+        end
+
+        def combine_nametemplate(parts, size)
+          case size
+          when 1 then parts[0] + parts[3]
+          when 2 then parts[0] + parts[2] + parts[3]
+          else parts.join
+          end
+        end
+
+        def nametemplate_split(template)
+          curr = 0
+          prec = ""
+          @in_name = 0
+          t = template.split(/(\{[{%][^{]+?[}%]\})/)
+            .each_with_object([""]) do |n, m|
+            m, curr, prec = nametemplate_split1(n, m, curr, prec)
+
+            m
+          end
+          [t[0], t[1], t[-1], prec]
+        end
+
+        def nametemplate_split1(elem, acc, curr, prec)
+          if match = /\{[{%].+?\[(\d)\]/.match(elem)
+            # we are in a name component
+            # if an if is started, track the if nesting...
+            @in_name += 1 if /\{%\s*if/.match?(elem)
+            if match[1].to_i > curr
+              curr += 1
+              acc[curr] ||= ""
+            end
+            acc[curr] += prec
+            prec = ""
+            acc[curr] += elem
+          elsif /\{%\s*endif/.match?(elem) && @in_name.positive?
+            # stick the endif to the currently if-nested name component,
+            # if we are in one (@in_name.positive?)
+            @in_name -= 1
+            acc[curr] += prec
+            prec = ""
+            acc[curr] += elem
+          else prec += elem
+          end
+          [acc, curr, prec]
+        end
+      end
+
+      class AuthorCite < Name
+      end
+
+      class Cite < General
+        def template_select(hash)
+          if hash[:citestyle].to_sym == :short
+            @template[hash[:type].to_sym]
+          else
+            @template[hash[:citestyle].to_sym]
+          end
+        end
+
+        def citation_styles
+          @template.keys
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,230 @@
+# require_relative "../utils/utils"
+require "liquid"
+require_relative "liquid"
+require_relative "hash_utils"
+require "singleton"
+require "htmlentities"
+
+module Relaton
+  module Render
+    module Template
+      class CacheManager
+        include Singleton
+
+        attr_accessor :mutex
+
+        Hash.include ::Relaton::Render::Legacy::HashCompat
+        Array.include ::Relaton::Render::Legacy::ArrayCompat
+
+        def initialize
+          @cache = {}
+          @mutex = Mutex.new
+        end
+
+        def store(key, value)
+          @cache[key] = value
+        end
+
+        def retrieve(key)
+          @cache[key]
+        end
+
+        def clear
+          @cache.clear
+        end
+      end
+
+      class General
+        attr_reader :template_raw
+
+        def initialize(opt = {})
+          @htmlentities = HTMLEntities.new
+          @templatecache = CacheManager.instance
+          @liquid_env = create_liquid_environment
+          parse_options(opt)
+        end
+
+        def parse_options(opt)
+          # opt = Utils::sym_keys(opt)
+          opt = opt.symbolize_all_keys
+          @i18n = opt[:i18n]
+          @template_raw = opt[:template].dup
+          @template =
+            case opt[:template]
+            when Hash
+              opt[:template].transform_values { |x| template_process(x) }
+            when Array then opt[:template].map { |x| template_process(x) }
+            else { default: template_process(opt[:template]) }
+            end
+        end
+
+        def create_liquid_environment
+          env = ::Liquid::Environment.new
+          env.register_filter(::Relaton::Render::Template::CustomFilters)
+          env
+        end
+
+        # denote start and end of variable,
+        # so that we can detect empty variables in postprocessing
+        VARIABLE_DELIM = "%%".freeze
+
+        # denote citation components which get delimited by period conventionally
+        COMPONENT_DELIM = Regexp.quote("$$$").freeze
+
+        # escape < >
+        LT_DELIM = "\u0019".freeze
+        GT_DELIM = "\u001a".freeze
+
+        # use tab internally for non-spacing delimiter
+        NON_SPACING_DELIM = "\t".freeze
+
+        def punct_field?(name)
+          name or return false
+          name = name.tr("'", '"')
+          %w(labels["punct"]["open-title"] labels["punct"]["close-title"]
+             labels["punct"]["open-secondary-title"]
+             labels["punct"]["close-secondary-title"]).include?(name)
+        end
+
+        def template_process(template)
+          template.is_a?(String) or return template
+          t = nil
+          @templatecache.mutex.synchronize do
+            unless t = @templatecache.retrieve(template)
+              t = ::Liquid::Template
+                .parse(add_field_delim_to_template(template), environment: @liquid_env)
+              @templatecache.store(template, t)
+            end
+          end
+          t
+        end
+
+        def add_field_delim_to_template(template)
+          t = template.split(/(\{\{|\}\})/).each_slice(4).map do |a|
+            unless !a[2] || punct_field?(a[2]&.strip)
+              a[1] = "#{VARIABLE_DELIM}{{"
+              a[3] = "}}#{VARIABLE_DELIM}"
+            end
+            a.join
+          end.join.tr("\t", " ")
+          t.gsub(/\}\}#{VARIABLE_DELIM}\|/o, "}}#{VARIABLE_DELIM}#{NON_SPACING_DELIM}")
+            .gsub(/\|#{VARIABLE_DELIM}\{\{/o, "#{NON_SPACING_DELIM}#{VARIABLE_DELIM}{{")
+        end
+
+        # hash is what to render, which can be entire bib entry,
+        # or a subset of it like names
+        # context is information for selecting i18n, which is entire bib entry,
+        # potentially enhanced
+        def render(hash, context)
+          t = template_select(hash) or return nil # TODO select on context?
+          i = @i18n.select(context)
+          i18nsettings = { "labels" => i.get, "lang" => i.lang,
+                           "script" => i.script, "locale" => i.locale }
+          ret = template_clean(t.render(liquid_hash(hash.merge(i18nsettings))))
+          bib_delim = i.get.dig("punct", "biblio-field-delimiter") || ". "
+          template_components(ret, bib_delim, context)
+        end
+
+        def template_select(_hash)
+          @template[:default]
+        end
+
+        def template_clean(str)
+          str = str.gsub(/&#x3c;/i, LT_DELIM).gsub(/&#x3e;/i, GT_DELIM)
+          str = template_clean1(@htmlentities.decode(str))
+          /[[:alnum:]]/.match?(str) or return nil
+          str.strip.gsub(/#{LT_DELIM}/o, "&#x3c;")
+            .gsub(/#{GT_DELIM}/o, "&#x3e;")
+            .gsub(/&(?!#\S+?;)/, "&#x26;")
+        end
+
+        def template_clean1(str)
+          str = strip_empty_variables(str)
+          str.gsub(/([,:;]\s*)+<\/esc>([,:;])(\s|_|$)/, "\\2</esc>\\3")
+            .gsub(/([,:;]\s*)+([,:;](\s|_|$))/, "\\2")
+            .gsub(/([,.:;]\s*)+<\/esc>([.])(\s|_|$)/, "\\2</esc>\\3") # move outside
+            .gsub(/([,.:;]\s*)+([.](\s|_|$))/, "\\2") # move outside
+            .gsub(/([,:;]\s*)+<\/esc>(,)(\s|_|$)/, "\\2</esc>\\3")
+            .gsub(/([,:;]\s*)+(,(\s|_|$))/, "\\2")
+            .gsub(/([,:;]\s*)+(#{COMPONENT_DELIM})/o, "\\2")
+            .gsub(/(:\s+)(&\s)/, "\\2")
+            .gsub(/\s+([,.:;)])/, "\\1") # trim around $$$
+            .sub(/^\s*[,.:;]\s*/, "") # no init $$$
+            .sub(/[,:;]\s*$/, "")
+            .gsub(/(?<!\\)_/, " ")
+            .gsub("\\_", "_")
+            .gsub(/(?<!#{COMPONENT_DELIM})#{NON_SPACING_DELIM}(?!#{COMPONENT_DELIM})/o, "") # preserve NON_SPACING_DELIM near $$$
+            .gsub(/[\n\r ]+/, " ")
+            .gsub(/<(\/)?esc>/i, "<\\1esc>")
+        end
+
+        # get rid of all empty variables, and any text around them,
+        # including component delimiters:
+        # [{{}}]$$$ => ""
+        # [{{}}] $$$ => " $$$"
+        def strip_empty_variables(str)
+          str.gsub(/\S*#{VARIABLE_DELIM}#{VARIABLE_DELIM}\S*/o, "")
+            .gsub(/#{VARIABLE_DELIM}/o, "")
+        end
+
+        # delim = punct.biblio-field-terminator must not be i18n'ised:
+        # .</esc>. deletes first .
+        # .</esc>。does not delete first .
+        # So we do not want to pass delim in as .,
+        # and then have it i18n to 。after we are done parsing
+        #
+        # Do not strip any delimiters from final field in string
+        #
+        # if delim = ". " , then: ({{ series }}$$$|) => (series1.)
+        def template_components(str, delim, context)
+          str or return str
+          delimrstrip, delimre, delimrstripre = template_components_prep(delim)
+          ret = template_components_split(str, delimre)
+          delim != delimrstrip and # "." in field followed by ". " in delim
+            ret = remove_double_period(ret, delimrstripre)
+          context[:citestyle] == "short" and
+            ret[0] += "<span class='fmt-first-biblio-delim'/>"
+          ret.join(delim).gsub(/#{delim}\|/, delimrstrip)
+        end
+
+        def template_components_split(str, delimre)
+          ret = str.gsub(NON_SPACING_DELIM, "|").split(/#{COMPONENT_DELIM}/o)
+            .map(&:strip).reject(&:empty?)
+          ret[0...-1].map do |s|
+            s.sub(/#{delimre}$/, "").sub(%r[#{delimre}(</[^>]+>)$], "\\1")
+          end + [ret.last]
+        end
+
+        def remove_double_period(ret, delimrstripre)
+          ret[0...-1].map do |s|
+            s.sub(/#{delimrstripre}$/, "")
+              .sub(%r[#{delimrstripre}(</[^>]+>)$], "\\1")
+          end + [ret.last]
+        end
+
+        def template_components_prep(delim)
+          [delim.rstrip, Regexp.quote(delim),
+           # if delim is esc'd, ignore the escs in the preceding span
+           Regexp.quote(delim.rstrip.gsub(%r{</?esc>}, ""))]
+        end
+
+        # need non-breaking spaces in fields: "Updated:_nil" ---
+        # we want the "Updated:" deleted,
+        # even if it's multiple words, as in French Mise_à_jour.
+        def liquid_hash(hash)
+          case hash
+          when Hash
+            hash.map { |k, v| [k.to_s, liquid_hash(v)] }.to_h
+          when Array
+            hash.map { |v| liquid_hash(v) }
+          when String
+            hash.empty? ? nil : hash.gsub("_", "\\_").tr(" ", "_")
+          else hash
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative "subclasses"

data/lib/relaton/render/version.rb

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

data/lib/relaton-render.rb

@@ -2,3 +2,17 @@
 
 require "relaton/render/version"
 require "relaton/render/iso690"
+
+module Relaton
+  module Render
+    # Deprecated 1.x engine leaves, restored so flavor gems that still
+    # subclass them load against this line. Superseded by the Iso690
+    # engine; removed when the flavors have migrated to CitationStyle
+    # instances. Referencing a constant loads its tree on demand.
+    autoload :Parse, "relaton/render/parse/parse"
+    autoload :Fields, "relaton/render/fields/fields"
+    autoload :Date, "relaton/render/fields/date"
+    autoload :Template, "relaton/render/template/template"
+    autoload :Citations, "relaton/render/legacy/citations"
+  end
+end

data/relaton-render.gemspec

@@ -21,6 +21,11 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.required_ruby_version = Gem::Requirement.new(">= 3.3.0")
 
+  spec.add_dependency "htmlentities"
+  spec.add_development_dependency "relaton-bib"
+  spec.add_dependency "liquid", "~> 5"
   spec.add_dependency "lutaml-model"
+  spec.add_dependency "nokogiri"
+  spec.add_dependency "twitter_cldr"
   # spec.metadata["rubygems_mfa_required"] = "true"
 end

metadata

@@ -1,15 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: relaton-render
 version: !ruby/object:Gem::Version
-  version: 1.4.0.pre.alpha.3
+  version: 3.0.0.pre.alpha.1
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-03 00:00:00.000000000 Z
+date: 2026-10-05 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: htmlentities
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: relaton-bib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: liquid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: lutaml-model
   requirement: !ruby/object:Gem::Requirement
@@ -24,6 +66,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: twitter_cldr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Rendering of ISO 690 XML
 email:
 - open.source@ribose.com
@@ -43,17 +113,9 @@ files:
 - bin/console
 - bin/rspec
 - bin/setup
-- lib/isodoc-yaml/i18n-ar.yaml
-- lib/isodoc-yaml/i18n-de.yaml
-- lib/isodoc-yaml/i18n-en.yaml
-- lib/isodoc-yaml/i18n-es.yaml
-- lib/isodoc-yaml/i18n-fr.yaml
-- lib/isodoc-yaml/i18n-ja.yaml
-- lib/isodoc-yaml/i18n-ru.yaml
-- lib/isodoc-yaml/i18n-zh-Hans.yaml
-- lib/isodoc-yaml/i18n-zh-Hant.yaml
-- lib/isodoc/i18n.rb
 - lib/relaton-render.rb
+- lib/relaton/render/fields/date.rb
+- lib/relaton/render/fields/fields.rb
 - lib/relaton/render/general.rb
 - lib/relaton/render/iso690.rb
 - lib/relaton/render/iso690/element.rb
@@ -86,6 +148,15 @@ files:
 - lib/relaton/render/iso690/style/type_template.rb
 - lib/relaton/render/iso690/styles/author-date.yml
 - lib/relaton/render/iso690/template.rb
+- lib/relaton/render/legacy/citations.rb
+- lib/relaton/render/parse/parse.rb
+- lib/relaton/render/parse/parse_contributors.rb
+- lib/relaton/render/parse/parse_extract.rb
+- lib/relaton/render/parse/parse_id.rb
+- lib/relaton/render/template/hash_utils.rb
+- lib/relaton/render/template/liquid.rb
+- lib/relaton/render/template/subclasses.rb
+- lib/relaton/render/template/template.rb
 - lib/relaton/render/version.rb
 - relaton-render.gemspec
 homepage: https://github.com/relaton/relaton-render

data/lib/isodoc/i18n.rb

@@ -1,34 +0,0 @@
-require "yaml"
-require "isodoc-i18n"
-
-module IsoDoc
-  class RelatonRenderI18n < I18n
-    def load_yaml1(lang, script)
-      case lang
-      when "en", "fr", "ru", "de", "es", "ar", "ja"
-        load_yaml2(lang)
-      when "zh"
-        case script
-        when "Hans", "Hant" then load_yaml2("zh-#{script}")
-        else load_yaml2("zh-Hans")
-        end
-      else load_yaml2("en")
-      end
-    end
-
-    def load_yaml2(str)
-      YAML.load_file(File.join(File.dirname(__FILE__),
-                               "../isodoc-yaml/i18n-#{str}.yaml"))
-    end
-
-    # force bidi for all i18n strings in Arabic,
-    # because of the potential for script mixing
-    def cleanup_entities(hash, is_xml: true)
-      ret = super
-      if @lang == "ar" && ret.include?("%")
-        ret = "&#x61c;#{ret}&#x61c;"
-      end
-      ret
-    end
-  end
-end