relaton-render 1.3.0 → 1.4.0.pre.alpha.1

data/lib/relaton/render/parse/parse_extract.rb

@@ -1,200 +0,0 @@
-module Relaton
-  module Render
-    class Parse
-      def host(doc)
-        doc.relation&.detect { |r| r.type == "includedIn" }&.bibitem
-      end
-
-      # TODO : first is naive choice
-      def title(doc)
-        doc.nil? || doc.title.nil? || doc.title.empty? and return nil
-        t = Array(doc.title).select { |x| x.language == @lang }
-        t.empty? and t = Array(doc.title)
-        t1 = t.select { |x| x.type == "main" }
-        t1.empty? and t1 = t
-        t1.first or return
-        esc(content(t1.first))
-      end
-
-      def medium(doc, host)
-        x = doc.medium || host&.medium or return nil
-        %w(content genre form carrier size scale).each_with_object({}) do |i, m|
-          m[i] = x.send i
-        end.compact
-      end
-
-      def size(doc)
-        x = doc.size or return nil
-        x.value.each_with_object({}) do |v, m|
-          m[v.type] ||= []
-          m[v.type] << v.content
-        end
-      end
-
-      def edition(doc, host)
-        ret = content(doc.edition || host&.edition)
-        ret &&= esc(ret)
-        ret
-      end
-
-      def edition_num(doc, host)
-        doc.edition&.number || host&.edition&.number
-      end
-
-      def place(doc, host)
-        x = Array(doc.place)
-        x.empty? && host and x = Array(host.place)
-        x.empty? and return x
-        x.map { |p| place1(p) }
-      end
-
-      def place1(place)
-        c = place.city
-        r = place.region
-        n = place.country
-        c.nil? && r.empty? && n.empty? and return place.formatted_place
-        [c, *r.map(&:content), *n.map(&:content)].compact.join(", ")
-      end
-
-      def series(doc)
-        doc.series&.detect { |s| s.type == "main" } ||
-          doc.series&.detect { |s| s.type.nil? } ||
-          doc.series&.first
-      end
-
-      def series_title(series, _doc)
-        series.nil? and return nil
-        t = Array(series.title).select { |x| x.language == @lang }
-        t.empty? and t = Array(series.title)
-        t1 = t.select { |x| x.type == "main" }
-        t1.empty? and t1 = t
-        t1.first.nil? and return nil
-        content(t1.first)
-      end
-
-      def series_formatted(series, _doc)
-        content(series.formattedref)
-      end
-
-      def series_abbr(series, _doc)
-        content(series.abbreviation)
-      end
-
-      def series_num(series, _doc)
-        series.number&.strip
-      end
-
-      def series_partnumber(series, _doc)
-        series.partnumber
-      end
-
-      def series_run(series, _doc)
-        series.run
-      end
-
-      def series_org(series, _doc)
-        series.organization
-      end
-
-      def series_place(series, _doc)
-        p = series.place or return nil
-        place1(p)
-      end
-
-      def series_dates(series, _doc)
-        f = series.from
-        t = series.to
-        f || t or return nil
-        "#{f}–#{t}"
-      end
-
-      def access_location(doc, host)
-        x = doc.accesslocation || host&.accesslocation or
-          return nil
-        Array(x).first
-      end
-
-      def included(type)
-        ["article", "inbook", "incollection", "inproceedings"].include? type
-      end
-
-      def type(doc)
-        type = doc.type and return type
-        doc.relation&.any? { |r| r.type == "includedIn" } and return "inbook"
-        "book"
-      end
-
-      def language(doc)
-        doc.language&.first || @lang
-      end
-
-      def script(doc)
-        doc.script&.first || @script
-      end
-
-      def locale(doc)
-        # TODO not yet implemented in relaton-bib
-        # doc.locale&.first
-      end
-
-      def extent1(localities)
-        localities.each_with_object({}) do |l, ret|
-          ret[(l.type || "page").to_sym] = {
-            from: localized_string_or_text(l.reference_from),
-            to: localized_string_or_text(l.reference_to),
-          }
-        end
-      end
-
-      def localized_string_or_text(str)
-        case str
-        when Relaton::Bib::LocalizedString then content(str)
-        when String then str
-        end
-      end
-
-      def extent(doc)
-        Array(doc.extent).each_with_object([]) do |e, acc|
-          case e
-          when Relaton::Bib::Extent, Relaton::Bib::LocalityStack
-            if e.locality.any?
-              a = e.locality.each_with_object([]) do |e1, m|
-                if e1.is_a?(Relaton::Bib::LocalityStack)
-                  m << extent1(e1.locality)
-                else
-                  m.empty? and m << {}
-                  m[-1].merge!(extent1(Array(e1)))
-                end
-              end
-              acc << a
-            else
-              Array(e.locality_stack).each do |stack|
-                a = stack.locality.each_with_object([{}]) do |e1, m|
-                  m[-1].merge!(extent1(Array(e1)))
-                end
-                acc << a
-              end
-            end
-          when Relaton::Bib::Locality
-            acc << extent1(Array(e))
-          end
-        end
-      end
-
-      def draft(doc, host)
-        { iteration: iter_ordinal(doc) || iter_ordinal(host),
-          status: status(doc) || status(host) }
-      end
-
-      def iter_ordinal(doc)
-        iter = doc&.status&.iteration or return nil
-        iter
-      end
-
-      def status(doc)
-        v = doc&.status&.stage&.content
-        #@i18n.get.dig("stage", v) || v
-      end
-    end
-  end
-end

data/lib/relaton/render/parse/parse_id.rb

@@ -1,128 +0,0 @@
-module Relaton
-  module Render
-    class Parse
-      # filter applied across full list of auth_id
-      def auth_id_filter(ids = [])
-        id_scope_filter(ids)
-      end
-
-      def id_scope_filter(ids)
-        ids.detect(&:scope) or return ids
-        id_sort_by_scope(ids).each_with_object([]) do |(k, v), m|
-          case k
-          when "IEEE"
-            f = id_extract_by_scope(v, "trademark")
-            f.empty? and f = id_extract_by_scope(v, nil)
-            m << f
-          else m << id_extract_by_scope(v, nil)
-          end
-        end.flatten
-      end
-
-      def id_sort_by_scope(ids)
-        ids.each_with_object({}) do |i, m|
-          m[i.type] ||= {}
-          m[i.type][i.scope] ||= []
-          m[i.type][i.scope] << i
-        end
-      end
-
-      def id_extract_by_scope(idents, key)
-        if idents.key?(key)
-          idents[key]
-        else []
-        end
-      end
-
-      # list of successive filters on individual auth_id instances
-      def auth_id_allow
-        [->(x) { x.language == @lang && x.primary },
-         ->(x) { x.primary },
-         ->(x) { x.language == @lang },
-         ->(_x) { true }]
-      end
-
-      def authoritative_identifier(doc)
-        out = []
-        [auth_id_filter(Array(doc.docidentifier)), Array(doc.docidentifier)].each do |a|
-          out = authoritative_identifier_select(a)
-          out.empty? or break
-        end
-        # prevent l10n of identifier contents
-        out.map(&:content).map { |i| esc(i.strip) }
-      end
-
-      def authoritative_identifier_select(idents)
-        out = []
-        auth_id_allow.each do |p|
-          out = idents.select do |x|
-            p.call(x) &&
-              !authoritative_identifier_exclude.include?(id_type_norm(x))
-          end
-          out.empty? or break
-        end
-        out
-      end
-
-      def authoritative_identifier_exclude
-        %w(METANORMA METANORMA-ORDINAL AUTHOR-DATE TITLE URN ISO-REFERENCE) +
-          other_identifier_include
-      end
-
-      def other_identifier(doc)
-        Array(doc.docidentifier).each_with_object([]) do |id, ret|
-          type = id_type_norm(id)
-          other_identifier_include.include? type or next
-          ret << [type, id.content]
-        end
-      end
-
-      def other_identifier_include
-        %w(ISSN ISBN DOI)
-      end
-
-      def doi(doc)
-        out = Array(doc.docidentifier).each_with_object([]) do |id, ret|
-          type = id.type&.sub(/^(DOI)\..*$/i, "\\1") or next
-          type.casecmp("doi").zero? or next
-          ret << id.content
-        end
-        out.empty? ? nil : out.map { |i| esc(i.strip) }
-      end
-
-      def id_type_norm(id)
-        id.type or return nil
-        m = /^(ISBN|ISSN)\./i.match(id.type) or return id.type.upcase
-        m[1].upcase
-      end
-
-      def biblio_tag(doc)
-        ret = Array(doc.docidentifier).detect do |id|
-          id.scope&.downcase == "biblio-tag"
-        end
-        ret&.content
-      end
-
-      def uri(doc)
-        uri = nil
-        %w(citation uri src).each do |t|
-          uri = uri_type_select(doc, t) and break
-        end
-        uri ||= Array(doc.source).detect do |u|
-          u.language == @lang && !u.type&.casecmp("doi")&.zero?
-        end
-        uri ||= Array(doc.source).detect { |u| !u.type&.casecmp("doi")&.zero? }
-        uri or return nil
-        uri.content.to_s.strip
-      end
-
-      def uri_type_select(doc, type)
-        uri = Array(doc.source).detect do |u|
-          u.type&.downcase == type && u.language == @lang
-        end and return uri
-        uri = Array(doc.source).detect { |u| u.type&.downcase == type } and return uri
-        nil
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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