relaton-render 0.5.10 → 3.0.0.pre.alpha.26

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

@@ -1,218 +0,0 @@
-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
-        FIELD_DELIM = "%%".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.gsub(/'/, '"')
-          %w(labels["qq-open"] labels["qq-close"] labels["q-open"]
-             labels["q-close"]).include?(name)
-        end
-
-        def template_process(template)
-          template.is_a?(String) or return template
-          ::Liquid::Template.parse(add_field_delim_to_template(template))
-        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] = "#{FIELD_DELIM}{{"
-              a[3] = "}}#{FIELD_DELIM}"
-            end
-            a.join
-          end.join.gsub(/\t/, " ")
-          t.gsub(/\}\}#{FIELD_DELIM}\|/o, "}}#{FIELD_DELIM}\t")
-            .gsub(/\|#{FIELD_DELIM}\{\{/o, "\t#{FIELD_DELIM}{{")
-        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(/\\_/, "_")
-            .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"]
-          @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 = ""
-          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)
-            if match[1].to_i > curr
-              curr += 1
-              acc[curr] ||= ""
-            end
-            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
-
-      class AuthorCite < Name
-      end
-    end
-  end
-end

data/lib/relaton/render/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