relaton-render 0.1.0 → 0.3.3

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

@@ -0,0 +1,129 @@
+module Relaton
+  module Render
+    class Parse
+      def extract_orgname(org)
+        org.name&.first&.content
+      end
+
+      def extract_personname(person)
+        surname = person.name.surname || person.name.completename
+        given, middle, initials = given_and_middle_name(person)
+        { surname: surname.content,
+          given: given,
+          middle: middle,
+          initials: initials }
+      end
+
+      def given_and_middle_name(person)
+        forenames = person.name.forename.map(&:content)
+        initials = person.name.initial.map(&:content)
+          .map { |x| x.sub(/\.$/, "") }
+        forenames.empty? and initials.empty? and return [nil, nil, nil]
+        initials.empty? and initials = forenames.map { |x| x[0] }
+        [forenames.first, forenames[1..-1], initials]
+      end
+
+      def extractname(contributor)
+        org = contributor.entity if contributor.entity
+          .is_a?(RelatonBib::Organization)
+        person = contributor.entity if contributor.entity
+          .is_a?(RelatonBib::Person)
+        return { nonpersonal: extract_orgname(org) } if org
+        return extract_personname(person) if person
+
+        nil
+      end
+
+      def contributor_role(contributors)
+        return nil unless contributors.length.positive?
+
+        desc = contributors[0].role.first.description.join("\n")
+        type = contributors[0].role.first.type
+        desc.empty? ? type : desc
+      end
+
+      def creatornames(doc)
+        cr = creatornames1(doc)
+        cr.empty? and return [nil, nil]
+        [cr.map { |x| extractname(x) }, contributor_role(cr)]
+      end
+
+      def creatornames_roles_allowed
+        %w(author performer adapter translator editor publisher distributor)
+      end
+
+      def creatornames1(doc)
+        cr = []
+        return [] if doc.nil?
+
+        creatornames_roles_allowed.each do |r|
+          add = pick_contributor(doc, r)
+          next if add.nil?
+
+          cr = add and break
+        end
+        cr.nil? and cr = doc.contributor
+        cr
+      end
+
+      def datepick(date)
+        return nil if date.nil?
+
+        on = date.on
+        from = date.from
+        to = date.to
+        return { on: on } if on
+        return { from: from, to: to } if from
+
+        nil
+      end
+
+      def date1(date)
+        %w(published issued circulated).each do |t|
+          ret = date.detect { |x| x.type == t } and
+            return ret
+        end
+        date.first
+      end
+
+      def date(doc, host)
+        ret = date1(doc.date)
+        host and ret ||= date1(host.date)
+        datepick(ret)
+      end
+
+      def date_updated(doc, host)
+        ret = doc.date.detect { |x| x.type == "updated" }
+        host and ret ||= host.date.detect { |x| x.type == "updated" }
+        datepick(ret)
+      end
+
+      def date_accessed(doc, host)
+        ret = doc.date.detect { |x| x.type == "accessed" }
+        host and ret ||= host.date.detect { |x| x.type == "accessed" }
+        datepick(ret)
+      end
+
+      def publisher(doc, host)
+        x = pick_contributor(doc, "publisher")
+        host and x ||= pick_contributor(host, "publisher")
+        x.nil? and return nil
+        x.map { |c| extractname(c) }
+      end
+
+      def publisher_abbrev(doc, host)
+        x = pick_contributor(doc, "publisher")
+        host and x ||= pick_contributor(host, "publisher")
+        x.nil? and return nil
+        x.map { |c| c.entity.abbreviation&.content }
+      end
+
+      def distributor(doc, host)
+        x = pick_contributor(doc, "distributor")
+        host and x ||= pick_contributor(host, "distributor")
+        x.nil? and return nil
+        x.map { |c| extractname(c) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,176 @@
+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)
+        return nil if doc.nil? || doc.title.empty?
+
+        t = doc.title.select { |x| x.title.language&.include? @lang }
+        t.empty? and t = doc.title
+        t1 = t.select { |x| x.type == "main" }
+        t1.empty? and t1 = t
+        t1.first&.title&.content
+      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.size.each_with_object({}) do |v, m|
+          m[v.type] ||= []
+          m[v.type] << v.value
+        end
+      end
+
+      def edition(doc, host)
+        doc.edition || host&.edition
+      end
+
+      def place(doc, host)
+        x = doc.place
+        x.empty? && host and x = host.place
+        x.empty? and return x
+        x.map(&:name)
+      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)
+        return nil if series.nil?
+
+        series.title.respond_to?(:titles) and
+          return series.title.titles.first.title.content
+        series.title&.title&.content || series.formattedref&.content
+      end
+
+      def series_formatted(series, _doc)
+        series.formattedref&.content
+      end
+
+      def series_abbr(series, _doc)
+        series.abbreviation&.content
+      end
+
+      def series_num(series, _doc)
+        series.number
+      end
+
+      def series_partnumber(series, _doc)
+        series.partnumber
+      end
+
+      def series_run(series, _doc)
+        series.run
+      end
+
+      def standardidentifier(doc)
+        doc.docidentifier.each_with_object([]) do |id, ret|
+          ret << id.id unless standardidentifier_exclude.include? id.type
+        end
+      end
+
+      def standardidentifier_exclude
+        %w(metanorma metanorma-ordinal)
+      end
+
+      def uri(doc)
+        uri = nil
+        %w(doi uri src).each do |t|
+          uri = doc.link.detect { |u| u.type == t } and break
+        end
+        uri ||= doc.link.first
+        return nil unless uri
+
+        uri.content.to_s
+      end
+
+      def access_location(doc, host)
+        x = doc.accesslocation || host&.accesslocation or
+          return nil
+        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 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 extent(doc)
+        doc.extent.each_with_object([]) do |e, acc|
+          case e
+          when RelatonBib::LocalityStack
+            acc << extent1(e.locality)
+          when RelatonBib::Locality
+            acc << extent1(Array(e))
+          end
+        end
+      end
+
+      def draft(doc, host)
+        dr = doc.status&.stage&.value || host&.status&.stage&.value
+
+        { iteration: iter_ordinal(doc) || iter_ordinal(host), status: dr }
+      end
+
+      def iter_ordinal(doc)
+        return nil unless iter = doc&.status&.iteration
+
+        iter
+      end
+
+      def status(doc)
+        doc.status&.stage&.value
+      end
+
+      private
+
+      def blank?(text)
+        text.nil? || text.empty?
+      end
+
+      def pick_contributor(doc, role)
+        ret = doc.contributor.select do |c|
+          c.role.any? { |r| r.type == role }
+        end
+        ret.empty? ? nil : ret
+      end
+
+      def localized_string_or_text(str)
+        case str
+        when RelatonBib::LocalizedString
+          str.content
+        when String
+          str
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Relaton
+  module Render
+    module Template
+      module CapitalizeFirst
+        def capitalize_first(words)
+          return nil if words.nil?
+
+          ret = words.split(/[ _]/)
+          ret.first.capitalize! if ret.size.positive?
+          ret.join("_")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,184 @@
+require_relative "../utils/utils"
+require_relative "liquid"
+
+module Relaton
+  module Render
+    module Template
+      class General
+        def initialize(opt = {})
+          @htmlentities = HTMLEntities.new
+          customise_liquid
+          parse_options(opt)
+        end
+
+        def parse_options(opt)
+          opt = Utils::sym_keys(opt)
+          @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 customise_liquid
+          ::Liquid::Template
+            .register_filter(::Relaton::Render::Template::CapitalizeFirst)
+        end
+
+        # denote start and end of field,
+        # so that we can detect empty fields in postprocessing
+        FIELD_DELIM = "\u0018".freeze
+
+        # escape < >
+        LT_DELIM = "\u0019".freeze
+        GT_DELIM = "\u001a".freeze
+
+        # use tab internally for non-spacing delimiter
+        NON_SPACING_DELIM = "\t".freeze
+
+        def template_process(template)
+          t = template.gsub(/\{\{/, "#{FIELD_DELIM}{{")
+            .gsub(/\}\}/, "}}#{FIELD_DELIM}")
+            .gsub(/\t/, " ")
+          t1 = t.split(/(\{\{.+?\}\})/).map do |n|
+            n.include?("{{") ? n : n.gsub(/(?<!\\)\|/, "\t")
+          end.join
+          ::Liquid::Template.parse(t1)
+        end
+
+        def render(hash)
+          t = template_select(hash) or return nil
+
+          template_clean(t.render(liquid_hash(hash.merge("labels" => @i18n.get))))
+        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
+
+        # use tab internally for non-spacing delimiter
+        def template_clean1(str)
+          str.gsub(/\S*#{FIELD_DELIM}#{FIELD_DELIM}\S*/o, "")
+            .gsub(/#{FIELD_DELIM}/o, "")
+            .gsub(/([,:;]\s*)+([,:;](\s|$))/, "\\2")
+            .gsub(/([,.:;]\s*)+([.](\s|$))/, "\\2")
+            .gsub(/([,:;]\s*)+(,(\s|$))/, "\\2")
+            .gsub(/(:\s+)(&\s)/, "\\2")
+            .gsub(/\s+([,.:;)])/, "\\1")
+            .sub(/^\s*[,.:;]\s*/, "")
+            .sub(/[,:;]\s*$/, "")
+            .gsub(/_/, " ")
+            .gsub(/#{NON_SPACING_DELIM}/o, "").gsub(/\s+/, " ")
+        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(/ /, "_")
+          else hash
+          end
+        end
+      end
+
+      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"]
+          opt[:template].delete("etal_count")
+          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
+            @template[:etal]
+          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
+          template_process(t[0] + mid.join + t[2].gsub(/\[2\]/,
+                                                       "[#{size - 1}]"))
+        end
+
+        def nametemplate_split(template)
+          curr = 0
+          prec = ""
+          t = template.split(/(\{[{%].+?[}%]\})/)
+            .each_with_object(["", "", ""]) do |n, m|
+            m, curr, prec = nametemplate_split1(n, m, curr, prec)
+
+            m
+          end
+          t[-1] += prec
+          t
+        end
+
+        def nametemplate_split1(elem, acc, curr, prec)
+          if match = /\{[{%].+?\[(\d)\]/.match(elem)
+            curr += 1 if match[1].to_i > curr
+            acc[curr] += prec
+            prec = ""
+            acc[curr] += elem
+          elsif /\{%\s*endif/.match?(elem)
+            acc[curr] += prec
+            prec = ""
+            acc[curr] += elem
+          else prec += elem
+          end
+          [acc, curr, prec]
+        end
+      end
+    end
+  end
+end

data/lib/relaton/{version.rb → render/version.rb}

@@ -1,5 +1,5 @@
 module Relaton
   module Render
-    VERSION = "0.1.0".freeze
+    VERSION = "0.3.3".freeze
   end
 end

data/lib/relaton-render.rb

@@ -1,6 +1,7 @@
-require "relaton/version"
-require "relaton/render"
-require "parse/parse"
-require "template/template"
+require "relaton/render/version"
+require "relaton/render/general/render"
+require "relaton/render/fields/fields"
+require "relaton/render/parse/parse"
+require "relaton/render/utils/utils"
 require "isodoc/i18n"
 

data/relaton-render.gemspec

@@ -1,6 +1,6 @@
 lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "relaton/version"
+require "relaton/render/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "relaton-render"
@@ -31,5 +31,8 @@ Gem::Specification.new do |spec|
   spec.add_dependency "isodoc-i18n"
   spec.add_dependency "liquid", "~> 4"
   spec.add_dependency "nokogiri"
+  spec.add_dependency "relaton-bib", ">= 1.11.0"
   spec.add_dependency "twitter_cldr"
+  spec.add_dependency "tzinfo-data" # we need this for windows only
+  #spec.metadata["rubygems_mfa_required"] = "true"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: relaton-render
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.3
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-04-01 00:00:00.000000000 Z
+date: 2022-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -136,6 +136,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: relaton-bib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.11.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.11.0
 - !ruby/object:Gem::Dependency
   name: twitter_cldr
   requirement: !ruby/object:Gem::Requirement
@@ -150,6 +164,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: tzinfo-data
+  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
@@ -175,17 +203,19 @@ files:
 - lib/isodoc-yaml/i18n-ru.yaml
 - lib/isodoc-yaml/i18n-zh-Hans.yaml
 - lib/isodoc/i18n.rb
-- lib/parse/parse.rb
-- lib/parse/parse_contributors.rb
-- lib/parse/parse_extract.rb
 - lib/relaton-render.rb
-- lib/relaton/config.yml
-- lib/relaton/render.rb
-- lib/relaton/render_classes.rb
-- lib/relaton/render_fields.rb
-- lib/relaton/version.rb
-- lib/template/template.rb
-- lib/utils/utils.rb
+- lib/relaton/render/fields/date.rb
+- lib/relaton/render/fields/fields.rb
+- lib/relaton/render/general/config.yml
+- lib/relaton/render/general/render.rb
+- lib/relaton/render/general/render_classes.rb
+- lib/relaton/render/parse/parse.rb
+- lib/relaton/render/parse/parse_contributors.rb
+- lib/relaton/render/parse/parse_extract.rb
+- lib/relaton/render/template/liquid.rb
+- lib/relaton/render/template/template.rb
+- lib/relaton/render/utils/utils.rb
+- lib/relaton/render/version.rb
 - relaton-render.gemspec
 homepage: https://github.com/relaton/relaton-render
 licenses:

data/lib/parse/parse.rb

@@ -1,54 +0,0 @@
-require "nokogiri"
-require "twitter_cldr"
-require_relative "parse_contributors"
-require_relative "parse_extract"
-
-class Iso690Parse
-  def initialize; end
-
-  def extract(doc)
-    host = doc.at("./relation[@type = 'includedIn']/bibitem")
-    simple_xml2hash(doc).merge(simple_or_host_xml2hash(doc, host))
-      .merge(host_xml2hash(host))
-      .merge(series_xml2hash(doc, host))
-  end
-
-  def simple_xml2hash(doc)
-    creators, role = creatornames(doc)
-    { type: type(doc), title: title(doc), extent_raw: extent(doc),
-      standardidentifier: standardidentifier(doc), uri: uri(doc),
-      status: status(doc), creators: creators, role_raw: role }
-  end
-
-  def simple_or_host_xml2hash(doc, host)
-    { edition_raw: edition(doc, host), medium: medium(doc, host),
-      place: place(doc, host), publisher: publisher(doc, host),
-      distributor: distributor(doc, host),
-      access_location: access_location(doc, host),
-      date: date(doc, host), date_updated: date_updated(doc, host),
-      date_accessed: date_accessed(doc, host) }
-  end
-
-  def host_xml2hash(host)
-    creators, role = creatornames(host)
-    { host_creators: creators, host_role_raw: role, host_title: title(host) }
-  end
-
-  def series_xml2hash(doc, host)
-    series = doc.at("./series[@type = 'main']") ||
-      doc.at("./series[not(@type)]") || doc.at("./series")
-    host and series ||=
-               host.at("./series[@type = 'main']") ||
-               host.at("./series[not(@type)]") || host.at("./series")
-
-    series_xml2hash1(series)
-  end
-
-  def series_xml2hash1(series)
-    return {} unless series
-
-    { series_title: series_title(series), series_abbr: series_abbr(series),
-      series_run: series_run(series), series_num: series_num(series),
-      series_partnumber: series_partnumber(series) }
-  end
-end