relaton-render 0.1.0 → 3.0.0.pre.alpha.25

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/relaton/version.rb

@@ -1,5 +0,0 @@
-module Relaton
-  module Render
-    VERSION = "0.1.0".freeze
-  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

data/lib/utils/utils.rb

@@ -1,27 +0,0 @@
-module Relaton
-  module Render
-    module Utils
-      def self.string_keys(hash)
-        case hash
-        when Hash
-          hash.each_with_object({}) do |(k, v), ret|
-            ret[k.to_s] = string_keys(v)
-          end
-        when Array then hash.map { |n| string_keys(n) }
-        else hash
-        end
-      end
-
-      def self.sym_keys(hash)
-        case hash
-        when Hash
-          hash.each_with_object({}) do |(k, v), ret|
-            ret[k.to_sym] = sym_keys(v)
-          end
-        when Array then hash.map { |n| sym_keys(n) }
-        else hash
-        end
-      end
-    end
-  end
-end