relaton-render 0.5.10 → 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,67 +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"
-        @i18n = options[:i18n]
-      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), uri_raw: uri(doc),
-          authoritative_identifier: authoritative_identifier(doc),
-          other_identifier: other_identifier(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), draft_raw: draft(doc, host),
-          place_raw: place(doc, host), publisher_raw: publisher(doc, host),
-          publisher_abbrev_raw: publisher_abbrev(doc, host),
-          authorizer_raw: authorizer(doc, host),
-          distributor_raw: 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 = 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,170 +0,0 @@
-module Relaton
-  module Render
-    class Parse
-      def content(node)
-        node.nil? and return node
-        node.content.is_a?(Array) and return node.content.map { |x| content(x) }
-        node.content.strip
-      end
-
-      def extract_orgname(org)
-        content(org.name&.first)
-      end
-
-      def extract_personname(person)
-        surname = person.name.surname || person.name.completename
-        given, middle, initials = given_and_middle_name(person)
-        { surname: content(surname),
-          given: given,
-          middle: middle,
-          initials: initials }
-      end
-
-      def given_and_middle_name(person)
-        forenames = person.name.forename.map do |x|
-          x.content.empty? ? "#{x.initial}." : content(x)
-        end
-        initials = content(person.name.initials)&.sub(/(.)\.?$/, "\\1.")
-          &.split /(?<=\.) /
-        initials ||= person.name.forename.map(&:initial)
-          .compact.map { |x| x.sub(/(.)\.?$/, "\\1.") }
-        forenames.empty? and initials.empty? and return [nil, nil, nil]
-        initials.empty? and initials = forenames.map { |x| "#{x[0]}." }
-        [forenames.first, forenames[1..-1], Array(initials)]
-      end
-
-      def forenames_parse(person)
-        person.name.forename.map do |x|
-          x.content.empty? ? "#{x.initial}." : content(x)
-        end
-      end
-
-      # de S. => one initial, M.-J. => one initial
-      def initials_parse(person)
-        i = content(person.name.initials) or
-          return person.name.forename.map(&:initial)
-              .compact.map { |x| x.sub(/(.)\.?$/, "\\1.") }
-
-        i.sub(/(.)\.?$/, "\\1.")
-          .scan(/.+?\.(?=(?:$|\s|\p{Alpha}))/).map(&:strip)
-      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 distributor authorizer)
-      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
-
-      # year-only
-      def date(doc, host)
-        ret = date1(doc.date)
-        host and ret ||= date1(host.date)
-        datepick(ret)&.transform_values do |v|
-          v&.sub(/-.*$/, "")
-        end
-      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|
-          content(c.entity.abbreviation) ||
-            content(c.entity.name.first)
-        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
-
-      def authorizer(doc, host)
-        x = pick_contributor(doc, "authorizer") ||
-          pick_contributor(doc, "publisher")
-        host and x ||= pick_contributor(host, "authorizer") ||
-          pick_contributor(host, "publisher")
-        x.nil? and return nil
-        x.map { |c| extractname(c) }
-      end
-    end
-  end
-end

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

@@ -1,208 +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)
-        doc.nil? || doc.title.empty? and return nil
-        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
-        content(t1.first&.title)
-      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)
-        content(doc.edition || host&.edition)
-      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 { |p| place1(p) }
-      end
-
-      def place1(place)
-        place.city.nil? && place.region.empty? && place.country.empty? and
-          return place.name
-        ret = [place.city] + place.region.map(&:name) +
-          place.country.map(&:name)
-        @i18n.l10n(ret.compact.join(", "))
-      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)
-        series.nil? and return nil
-        series.title.respond_to?(:titles) && !series.title.titles.empty? and
-          return content(series.title.titles.first.title)
-        series.title.respond_to?(:title) and
-          return content(series.title.title)
-        series.title.respond_to?(:formattedref) and
-          content(series.formattedref)
-      end
-
-      def series_formatted(series, _doc)
-        content(series.formattedref)
-      end
-
-      def series_abbr(series, _doc)
-        content(series.abbreviation)
-      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 authoritative_identifier(doc)
-        doc.docidentifier.each_with_object([]) do |id, ret|
-          ret << id.id unless authoritative_identifier_exclude.include? id.type
-        end
-      end
-
-      def authoritative_identifier_exclude
-        %w(metanorma metanorma-ordinal) + other_identifier_include
-      end
-
-      def other_identifier(doc)
-        doc.docidentifier.each_with_object([]) do |id, ret|
-          type = id.type&.sub(/^(ISBN|ISSN)\..*$/, "\\1")
-          other_identifier_include.include? type or next
-          ret << @i18n.l10n("#{type}: #{id.id}")
-        end
-      end
-
-      def other_identifier_include
-        %w(ISSN ISBN DOI)
-      end
-
-      def uri(doc)
-        uri = nil
-        %w(citation uri src).each do |t|
-          uri = uri_type_select(doc, t) and break
-        end
-        uri ||= doc.link.detect do |u|
-          u.language == @lang && !u.type&.casecmp("doi")&.zero?
-        end
-        uri ||= doc.link.detect { |u| !u.type&.casecmp("doi")&.zero? }
-        uri or return nil
-        uri.content.to_s.strip
-      end
-
-      def uri_type_select(doc, type)
-        uri = doc.link.detect do |u|
-          u.type&.downcase == type && u.language == @lang
-        end and return uri
-        uri = doc.link.detect { |u| u.type&.downcase == type } and return uri
-        nil
-      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)
-        { iteration: iter_ordinal(doc) || iter_ordinal(host),
-          status: status(doc) || status(host) }
-      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 then content(str)
-        when String then 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