relaton-render 0.1.0 → 0.3.1

data/lib/parse/parse_extract.rb

@@ -1,155 +0,0 @@
-class Iso690Parse
-  def title(doc)
-    doc&.at("./title")&.text
-  end
-
-  def medium(doc, host)
-    x = doc.at("./medium") || host&.at("./medium") or return nil
-
-    %w(content genre form carrier size scale).each_with_object([]) do |i, m|
-      m << x.at("./#{i}")&.text
-    end.compact.join(", ")
-  end
-
-  def blank?(text)
-    text.nil? || text.empty?
-  end
-
-  def edition(doc, host)
-    x = doc.at("./edition") || host&.at("./edition") or return nil
-
-    x.text
-  end
-
-  def place(doc, host)
-    x = doc.at("./place") || host&.at("./place") or return nil
-
-    x.text
-  end
-
-  def publisher(doc, host)
-    x = doc.at("./contributor[role/@type = 'publisher']/organization/name") ||
-      host&.at("./contributor[role/@type = 'publisher']/organization/name") or
-      return nil
-    x.text
-  end
-
-  def distributor(doc, host)
-    x = doc.at("./contributor[role/@type = 'distributor']/organization/name") ||
-      host&.at("./contributor[role/@type = 'distributor']/organization/name") or
-      return nil
-    x.text
-  end
-
-  def series_title(doc)
-    doc&.at("./title")&.text || doc&.at("./formattedref")&.text
-  end
-
-  def series_abbr(doc)
-    doc&.at("./abbreviation")&.text
-  end
-
-  def series_num(doc)
-    doc&.at("./number")&.text
-  end
-
-  def series_partnumber(doc)
-    doc&.at("./partnumber")&.text
-  end
-
-  def series_run(doc)
-    doc&.at("./run")&.text
-  end
-
-  def standardidentifier(doc)
-    doc.xpath("./docidentifier").each_with_object([]) do |id, ret|
-      ret << id.text unless %w(metanorma metanorma-ordinal).include? id["type"]
-    end
-  end
-
-  def uri(doc)
-    uri = doc.at("./uri[@type = 'doi']") || doc.at("./uri[@type = 'uri']") ||
-      doc.at("./uri[@type = 'src']") || doc.at("./uri")
-    uri&.text
-  end
-
-  def access_location(doc, host)
-    x = doc.at("./accessLocation") || host&.at("./accessLocation") or
-      return nil
-    x.text
-  end
-
-  def included(type)
-    ["article", "inbook", "incollection", "inproceedings"].include? type
-  end
-
-  def wrap(text, startdelim = " ", enddelim = ".")
-    return "" if blank?(text)
-
-    "#{startdelim}#{text}#{enddelim}"
-  end
-
-  def type(doc)
-    type = doc.at("./@type") and return type&.text
-    doc.at("./relation[@type = 'includedIn']") and return "inbook"
-    "book"
-  end
-
-  def extent1(localities)
-    localities.each_with_object({}) do |l, ret|
-      ret[(l["type"] || "page").to_sym] = {
-        from: l.at("./referenceFrom")&.text,
-        to: l.at("./referenceTo")&.text,
-      }
-    end
-  end
-
-  def extent0(elem, acc, ret1)
-    case elem.name
-    when "localityStack"
-      acc << ret1
-      ret1 = {}
-      acc << extent1(elem.elements)
-    when "locality" then ret1.merge!(extent1([elem]))
-    when "referenceFrom" then ret1.merge!(extent1([elem.parent]))
-    end
-    [acc, ret1]
-  end
-
-  def extent(doc)
-    ret1 = {}
-    ret = doc.xpath("./extent").each_with_object([]) do |e, acc|
-      e.elements.each do |l|
-        acc, ret1 = extent0(l, acc, ret1)
-        break if l.name == "referenceFrom"
-      end
-    end
-    ret << ret1
-    ret.reject(&:empty?)
-  end
-
-  def draft(doc)
-    dr = doc&.at("./status/stage")&.text
-
-    iterord = iter_ordinal(doc)
-    status = status_print(dr)
-    status = "#{iterord} #{status}" if iterord
-    status
-  end
-
-  def iter_ordinal(isoxml)
-    return nil unless isoxml.at(("./status/iteration"))
-
-    iter = isoxml.at(("./status/iteration"))&.text || "1"
-    iter.to_i.localize.to_rbnf_s("SpelloutRules",
-                                 "spellout-ordinal").capitalize
-  end
-
-  def status_print(status)
-    status
-  end
-
-  def status(doc)
-    doc&.at("./status/stage")&.text
-  end
-end

data/lib/relaton/render_fields.rb

@@ -1,151 +0,0 @@
-module Relaton
-  module Render
-    class Fields
-      def initialize(options)
-        @r = options[:renderer]
-      end
-
-      def compound_fields_format(hash)
-        name_fields_format(hash)
-        role_fields_format(hash)
-        date_fields_format(hash)
-        misc_fields_format(hash)
-      end
-
-      def name_fields_format(hash)
-        hash[:creatornames] = nameformat(hash[:creators])
-        hash[:host_creatornames] = nameformat(hash[:host_creators])
-      end
-
-      def role_fields_format(hash)
-        hash[:role] = role_inflect(hash[:creators], hash[:role_raw])
-        hash[:host_role] =
-          role_inflect(hash[:host_creators], hash[:host_role_raw])
-      end
-
-      def misc_fields_format(hash)
-        hash[:series] = seriesformat(hash)
-        hash[:edition] = editionformat(hash[:edition_raw])
-        hash[:extent] = extentformat(hash[:extent_raw], hash)
-        hash
-      end
-
-      def date_fields_format(hash)
-        hash[:date] = dateformat(hash[:date], hash)
-        hash[:date_updated] = dateformat(hash[:date_updated], hash)
-        hash[:date_accessed] = dateformat(hash[:date_accessed], hash)
-      end
-
-      def seriesformat(hash)
-        parts = %i(series_title series_abbr series_num series_partnumber
-                   series_run)
-        series_out = parts.each_with_object({}) do |i, m|
-          m[i] = hash[i]
-        end
-        t = hash[:type] == "article" ? @r.journaltemplate : @r.seriestemplate
-        t.render(series_out)
-      end
-
-      def nameformat(names)
-        return names if names.nil?
-
-        parts = %i(surname initials given middle)
-        names_out = names.each_with_object({}) do |n, m|
-          parts.each do |i|
-            m[i] ||= []
-            m[i] << n[i]
-          end
-        end
-        @r.nametemplate.render(names_out)
-      end
-
-      def role_inflect(contribs, role)
-        return nil if role.nil? || contribs.size.zero?
-
-        number = contribs.size > 1 ? "pl" : "sg"
-        @r.i18n.get[role][number] || role
-      end
-
-      def editionformat(edn)
-        return edn unless /^\d+$/.match?(edn)
-
-        num = edn.to_i.localize(@r.lang.to_sym)
-          .to_rbnf_s(*@r.edition_number)
-        @r.edition.sub(/%/, num)
-      end
-
-      def extentformat(extent, hash)
-        extent.map do |e|
-          extent_out = e.merge(type: hash[:type],
-                               host_title: hash[:host_title])
-            .transform_values do |v|
-              v.is_a?(Hash) ? range(v) : v
-            end
-          @r.extenttemplate.render(extent_out.merge(orig: e))
-        end.join("; ")
-      end
-
-      def range(hash)
-        if hash[:on] then hash[:on]
-        elsif hash.has_key?(:from) && hash[:from].nil? then nil
-        elsif hash[:from]
-          hash[:to] ? "#{hash[:from]}&#x2013;#{hash[:to]}" : hash[:from]
-        else hash
-        end
-      end
-
-      def date_range(hash)
-        if hash[:from]
-          "#{hash[:from]}&#x2013;#{hash[:to]}"
-        else range(hash)
-        end
-      end
-
-      def dateformat(date, hash)
-        return nil if date.nil?
-
-        %i(from to on).each do |k|
-          date[k] = daterender(date[k], hash)
-        end
-        date_range(date)
-      end
-
-      def daterender(date, _hash)
-        return date if date.nil? || /^\d+$/.match?(date)
-
-        daterender1(date, dategranularity(date), hash)
-      end
-
-      def daterender1(date, format, _hash)
-        datef = dateparse(date, format, @r.lang.to_sym)
-        case @r.date[format]
-        when "to_full_s", "to_long_s", "to_medium_s", "to_short_s"
-          datef.send @r.date[format]
-        else
-          datef.to_additional_s(@r.date[format])
-        end
-      end
-
-      private
-
-      def dategranularity(date)
-        case date
-        when /^\d+-\d+$/ then "month_year"
-        when /^\d+-\d+-\d+$/ then "day_month_year"
-        else "date_time"
-        end
-      end
-
-      def dateparse(date, format, lang)
-        case format
-        when "date_time" then DateTime.parse(date)
-          .localize(lang, timezone: "Zulu")
-        when "day_month_year" then DateTime.parse(date)
-          .localize(lang, timezone: "Zulu").to_date
-        when "month_year" then Date.parse(date)
-          .localize(lang, timezone: "Zulu").to_date
-        end
-      end
-    end
-  end
-end

data/lib/template/template.rb

@@ -1,152 +0,0 @@
-require_relative "../utils/utils"
-
-module Relaton
-  module Render
-    class Iso690Template
-      def initialize(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
-
-      # denote start and end of field,
-      # so that we can detect empty fields in postprocessing
-      FIELD_DELIM = "\u0018".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)
-        template_clean(template_select(hash)
-          .render(liquid_hash(hash.merge("labels" => @i18n.get))))
-      end
-
-      def template_select(_hash)
-        @template[:default]
-      end
-
-      # use tab internally for non-spacing delimiter
-      def template_clean(str)
-        str = str.gsub(/\S*#{FIELD_DELIM}#{FIELD_DELIM}\S*/o, "")
-          .gsub(/#{FIELD_DELIM}/o, "")
-          .gsub(/_/, " ")
-          .gsub(/([,:;]\s*)+([,:;](\s|$))/, "\\2")
-          .gsub(/([,.:;]\s*)+([.](\s|$))/, "\\2")
-          .gsub(/(:\s+)(&\s)/, "\\2")
-          .gsub(/\s+([,.:;])/, "\\1")
-          .gsub(/#{NON_SPACING_DELIM}/o, "").gsub(/\s+/, " ")
-        str.strip
-      end
-
-      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
-        else hash
-        end
-      end
-    end
-
-    class Iso690SeriesTemplate < Iso690Template
-    end
-
-    class Iso690ExtentTemplate < Iso690Template
-      def template_select(hash)
-        t = @template_raw[hash[:type].to_sym]
-        hash.each do |k, _v|
-          next unless hash[:orig][k].is_a?(Hash)
-
-          num = number(hash[:type], hash[:orig][k])
-          t = t.gsub(/labels\[['"]extent['"]\]\[['"]#{k}['"]\]/,
-                     "\\0['#{num}']")
-        end
-        t = t.gsub(/labels\[['"]extent['"]\]\[['"][^\]'"]+['"]\](?!\[)/,
-                   "\\0['sg']")
-        template_process(t)
-      end
-
-      def number(type, value)
-        return "pl" if value[:to]
-        return "sg" if %w(article incollection inproceedings inbook)
-          .include?(type) || value[:host_title]
-
-        value[:from] == "1" ? "sg" : "pl"
-      end
-    end
-
-    class Iso690NameTemplate < Iso690Template
-      def initialize(opt = {})
-        @etal_count = opt[:template]["etal_count"]
-        opt[:template].delete("etal_count")
-        super
-      end
-
-      def template_select(names)
-        case names[:surname].size
-        when 1 then @template[:one]
-        when 2 then @template[:two]
-        when 3 then @template[:more]
-        else
-          if @etal_count && names.size >= @etal_count
-            @template[:etal]
-          else expand_nametemplate(@template_raw[:more], names.size)
-          end
-        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 - 1).each_with_object([]) do |i, m|
-          m << t[1].gsub(/\[1\]/, "[#{i}]")
-        end
-        template_process(t[0] + mid.join + t[2].gsub(/\[2\]/, "[#{size}]"))
-      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
-        else prec += elem
-        end
-        [acc, curr, prec]
-      end
-    end
-  end
-end