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

data/lib/relaton/render/general/render_classes.rb

@@ -1,129 +0,0 @@
-module Relaton
-  module Render
-    BIBTYPE =
-      %w(article book booklet manual proceedings presentation thesis techreport
-         standard unpublished map electronic_resource audiovisual film video
-         broadcast software graphic_work music patent inbook incollection
-         inproceedings journal website webresource dataset archival social_media
-         alert message conversation misc internal).freeze
-
-    class General
-      singleton_class.send(:attr_reader, :descendants)
-      @descendants = {}
-
-      def self.inherited(subclass) # rubocop:disable Lint/MissingSuper
-        type = subclass.name.downcase.sub(/relaton::render::/, "")
-        General.descendants[type] = subclass
-      end
-
-      def self.subclass(type)
-        @descendants[type]
-      end
-    end
-
-    class Book < General
-    end
-
-    class Journal < General
-    end
-
-    class Booklet < General
-    end
-
-    class Manual < General
-    end
-
-    class Proceedings < General
-    end
-
-    class Presentation < General
-    end
-
-    class Thesis < General
-    end
-
-    class Techreport < General
-    end
-
-    class Standard < General
-    end
-
-    class Unpublished < General
-    end
-
-    class Map < General
-    end
-
-    class Electronic_resource < General
-    end
-
-    class Software < Electronic_resource
-    end
-
-    class Webresource < Electronic_resource
-    end
-
-    class Website < Webresource
-    end
-
-    class Dataset < Electronic_resource
-    end
-
-    class Social_media < Electronic_resource
-    end
-
-    class Alert < Social_media
-    end
-
-    class Message < Social_media
-    end
-
-    class Audiovisual < General
-    end
-
-    class Film < Audiovisual
-    end
-
-    class Video < Audiovisual
-    end
-
-    class Broadcast < Audiovisual
-    end
-
-    class Graphic_work < General
-    end
-
-    class Music < General
-    end
-
-    class Patent < General
-    end
-
-    class Hosted < General
-    end
-
-    class Article < Hosted
-    end
-
-    class InBook < Hosted
-    end
-
-    class InCollection < Hosted
-    end
-
-    class InProceedings < Hosted
-    end
-
-    class Archival < General
-    end
-
-    class Conversation < General
-    end
-
-    class Misc < General
-    end
-
-    class Internal < General
-    end
-  end
-end

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

@@ -1,64 +0,0 @@
-require "nokogiri"
-require "twitter_cldr"
-require_relative "parse_contributors"
-require_relative "parse_extract"
-
-module Relaton
-  module Render
-    class Parse
-      def initialize(options)
-        @lang = options[:lang] || "en"
-        @script = options[:script] || "Latn"
-      end
-
-      def extract(doc)
-        host = host(doc)
-        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),
-          size_raw: size(doc),
-          standardidentifier: standardidentifier(doc), uri_raw: uri(doc),
-          status: status(doc), creators: creators, role_raw: role }
-      end
-
-      def simple_or_host_xml2hash(doc, host)
-        { edition_raw: edition(doc, host), edition_num: edition_num(doc, host),
-          medium_raw: medium(doc, host),
-          place_raw: place(doc, host), publisher_raw: publisher(doc, host),
-          publisher_abbrev_raw: publisher_abbrev(doc, host),
-          distributor_raw: distributor(doc, host), draft_raw: draft(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 = series(doc)
-        host and series ||= series(host)
-        series_xml2hash1(series, doc)
-      end
-
-      def series_xml2hash1(series, doc)
-        return {} unless series
-
-        { series_formatted: series_formatted(series, doc),
-          series_title: series_title(series, doc),
-          series_abbr: series_abbr(series, doc),
-          series_run: series_run(series, doc),
-          series_num: series_num(series, doc),
-          series_partnumber: series_partnumber(series, doc) }
-      end
-    end
-  end
-end

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

@@ -1,132 +0,0 @@
-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 do |c|
-          c.entity.abbreviation&.content ||
-            c.entity.name.first&.content
-        end
-      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

@@ -1,180 +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)
-        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&.content || host&.edition&.content
-      end
-
-      def edition_num(doc, host)
-        doc.edition&.number || host&.edition&.number
-      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

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

@@ -1,188 +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
-
-        # 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(/\\_/, "_")
-            .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
-
-      class AuthorCite < Name
-      end
-    end
-  end
-end