relaton 3.0.6 → 3.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 530a71ba433c39a2152315b7d8bf311a38535574ad3b15963f638d3f4167c788
-  data.tar.gz: dccf0ad46a1d5b22ff533a00b80036514215de25704c90c0d7e83ec8fac7ce75
+  metadata.gz: c2d44cf8ad434afddc1e4b0b2b4ce979970271e7ce871c48a2bb436e42eccfee
+  data.tar.gz: '07891a8f6deafa0d294519798a4576e7de997d0faead9d02077d9ab840c5d2ab'
 SHA512:
-  metadata.gz: a69f5fa09b70b53a1de4634c770b65dda5f0263027d24515076fe0f854ff57b9e41d0c34356025fcfcfd35fc1022861bedfadd2608f630086337919c7b006898
-  data.tar.gz: c4e720cc11a28b7f74f79001bb7eceb5f0a2e2fd4a5308b5163fb189a12ea95c76b39d410c0c5815506097c9b7eeb6e31571a2b5b01e1c36f9a828516c9b7bed
+  metadata.gz: 5ca0eb885107187f7881e2fd42e665cebc70b6e9154f3b52cfeb8597037f5543dd9d921cb698a17e86723c86b592cef6bc19979051cc2bff7b4898c981c45840
+  data.tar.gz: ed359c58cb0ef93f972c0a30e8d89aed165841a9b392664241fa15f08d638fbf72a9e50c29994acc4bb5de3a7c0b0394c8bf9d801cf99c217c06b282e75089a3

data/bin/relaton

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+# resolve bin path, ignoring symlinks
+require "pathname"
+bin_file = Pathname.new(__FILE__).realpath
+
+# add self to libpath
+$:.unshift File.expand_path("../../lib", bin_file)
+
+# Fixes https://github.com/rubygems/rubygems/issues/1420
+require "rubygems/specification"
+
+class Gem::Specification
+  def this; self; end
+end
+
+require "relaton-cli"
+
+Relaton::Cli.start(ARGV)

data/lib/relaton/bib/model/docidentifier.rb

@@ -66,7 +66,7 @@ module Relaton
         "BSI" => :Bsi,
       }.freeze
 
-      FORMS = %i[external internal].freeze
+      FORMS = %i[external internal slug].freeze
 
       # The parsed identifier. A pubid-backed flavor subclass overrides it.
       def pubid; end
@@ -94,7 +94,22 @@ module Relaton
       def form_content(form)
         flavor = FORM_PUBID[type]
         id = flavor && (pubid || parse_form_pubid(flavor))
-        id ? id.to_s(with_publisher: form == :external) : content
+        return content unless id
+
+        return slug_form(id) if form == :slug
+
+        id.to_s(with_publisher: form == :external)
+      end
+
+      # The pubid-scheme slug (relaton#441): the URN in HTTP-path
+      # clothes, bijective with Pubid.from_slug. A flavor whose
+      # pubid-scheme schema has not landed yet degrades to the stored
+      # content, like a form pubid cannot parse.
+      def slug_form(id)
+        require "pubid"
+        ::Pubid.to_slug(id)
+      rescue ::Pubid::Errors::InvalidInputError, NameError
+        content
       end
 
       def parse_form_pubid(flavor)

data/lib/relaton/bibcollection.rb

@@ -0,0 +1,146 @@
+require "relaton/element_finder"
+
+module Relaton
+  class Bibcollection
+    extend Relaton::ElementFinder
+
+    ATTRIBS = %i[title items doctype author].freeze
+
+    attr_accessor(*ATTRIBS)
+
+    # @param options [Hash]
+    def initialize(options)
+      ATTRIBS.each do |k|
+        value = options[k] || options[k.to_s]
+        send("#{k}=", value)
+      end
+      reduce_items
+    end
+
+    # arbitrary number, must sort after all bib items
+    def doc_number
+      9999999
+    end
+
+    # Add a dcoument to the collection
+    # @param item [RelatonBib::BibliographicItem]
+    def <<(item)
+      items << new_bib_item_class(item)
+    end
+
+    # rubocop:disable Metrics/MethodLength
+
+    # @param source [Nokogiri::XML::Element]
+    def self.from_xml(source)
+      title = find_html("./relaton-collection/title", source)
+      author = find_html(
+        "./relaton-collection/contributor[role/@type='author']/organization/"\
+        "name", source
+      )
+
+      items = find_xpath("./relaton-collection/relation", source)&.map do |item|
+        bibdata = find("./bibdata|./bibitem", item)
+        klass = bibdata ? Bibdata : Bibcollection
+        klass.from_xml(bibdata || item)
+      end
+
+      new(title: title, author: author, items: items)
+    end
+
+    # rubocop:disable Metrics/AbcSize
+
+    # @param opts [Hash]
+    # @return [String] XML
+    def to_xml(opts = {})
+      items.sort_by! &:doc_number
+
+      collection_type = if doctype
+                          "type=\"#{doctype}\""
+                        else
+                          'xmlns="https://open.ribose.com/relaton-xml"'
+                        end
+
+      ret = "<relaton-collection #{collection_type}>"
+      ret += "<title>#{xml_escape(title)}</title>" if title
+      if author
+        ret += "<contributor><role type='author'/><organization><name>"\
+        "#{xml_escape(author)}</name></organization></contributor>"
+      end
+      unless items.empty?
+        items.each do |item|
+          ret += "<relation type='partOf'>"
+          ret += item.to_xml(opts)
+          ret += "</relation>\n"
+        end
+      end
+      ret += "</relaton-collection>\n"
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    # @param item [Hash, RelatonBib::BibliographicItem, Relatin::Bibdata,
+    #   Relaton::Bibcollection]
+    # @return [Relaton::Bibdata, Relaton::Bibcollection]
+    def new_bib_item_class(item)
+      if item.is_a?(Hash)
+        if item["items"]
+          ::Relaton::Bibcollection.new(item)
+        else
+          bibitem = ::Relaton::Cli::YAMLConvertor.convert_single_file item
+          ::Relaton::Bibdata.new bibitem
+        end
+      elsif item.is_a?(Relaton::Bibdata) || item.is_a?(Relaton::Bibcollection)
+        item
+      else ::Relaton::Bibdata.new(item)
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def items_flattened
+      items.sort_by! &:doc_number
+
+      items.reduce([]) do |acc, item|
+        acc << if item.is_a? ::Relaton::Bibcollection
+                 item.items_flattened
+               else
+                 item
+               end
+      end
+    end
+
+    def to_yaml
+      to_h.to_yaml
+    end
+
+    def to_h
+      items.sort_by! &:doc_number
+
+      a = ATTRIBS.reduce({}) do |acc, k|
+        acc[k.to_s] = send(k)
+        acc
+      end
+
+      a["items"] = a["items"].map(&:to_h)
+
+      { "root" => a }
+    end
+
+    private
+
+    def reduce_items
+      self.items = (items || []).reduce([]) do |acc, item|
+        acc << if item.is_a?(Bibcollection) || item.is_a?(Bibdata)
+                 item
+               else new_bib_item_class(item)
+               end
+      end
+    end
+
+    # Escape bare & in content for XML serialization, leaving already-encoded
+    # entity references (&amp;, &#123;, &#x1f;) and inline markup (<em> etc.)
+    # untouched. This prevents invalid XML when plain-text values (e.g. from
+    # YAML) contain literal ampersands.
+    def xml_escape(str)
+      str.gsub(/&(?![a-zA-Z][a-zA-Z0-9]*;|#[0-9]+;|#x[0-9a-fA-F]+;)/, "&amp;")
+    end
+  end
+end

data/lib/relaton/bibdata.rb

@@ -0,0 +1,92 @@
+require "date"
+
+module Relaton
+  class Bibdata
+    URL_TYPES = %i[uri xml pdf doc html rxl txt].freeze
+
+    # @return [RelatonBib::BibliographicItem]
+    attr_reader :bibitem
+
+    # @param bibitem [RelatonBib::BibliographicItem]
+    def initialize(bibitem)
+      @bibitem = bibitem
+    end
+
+    def docidentifier
+      @bibitem.docidentifier.first&.content&.to_s
+    end
+
+    # def doctype
+    #   @bibitem.type
+    # end
+
+    # From http://gavinmiller.io/2016/creating-a-secure-sanitization-function/
+    FILENAME_BAD_CHARS = ["/", '\\', "?", "%", "*", ":", "|", '"', "<", ">",
+                          ".", " "].freeze
+
+    def docidentifier_code
+      return "" if docidentifier.nil?
+
+      FILENAME_BAD_CHARS.reduce(docidentifier.downcase) do |result, bad_char|
+        result.gsub(bad_char, "-")
+      end
+    end
+
+    DOC_NUMBER_REGEX = /([\w\/]+)\s+(\d+):?(\d*)/.freeze
+    def doc_number
+      docidentifier&.match(DOC_NUMBER_REGEX) ? $2.to_i : 999999
+    end
+
+    def self.from_xml(source)
+      bi = Relaton::Cli.parse_xml(source)
+      new(bi) if bi
+    end
+
+    def to_xml(opts = {})
+      options = { bibdata: true, date_format: :full }.merge(
+        opts.select { |k, _v| k.is_a? Symbol },
+      )
+      @bibitem.to_xml(**options)
+    end
+
+    def to_h
+      URL_TYPES.each_with_object(YAML.safe_load(@bibitem.to_yaml)) do |t, h|
+        value = send t
+        h[t.to_s] = value if value
+      end
+    end
+
+    def to_yaml
+      to_h.to_yaml
+    end
+
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity, Style/MissingRespondToMissing
+
+    def method_missing(meth, *args)
+      if @bibitem.respond_to?(meth)
+        @bibitem.send meth, *args
+      elsif URL_TYPES.include? meth
+        source = (@bibitem.source || []).detect do |l|
+          l.type == meth.to_s || (meth == :uri && l.type.nil?)
+        end
+        source&.content&.to_s
+      elsif URL_TYPES.include? meth.match(/^\w+(?==)/).to_s.to_sym
+        /^(?<type>\w+)/ =~ meth
+        @bibitem.source ||= []
+        source = @bibitem.source.detect do |l|
+          l.type == type || (type == "uri" && l.type.nil?)
+        end
+        if source
+          source.content = args[0]
+        else
+          @bibitem.source << Relaton::Bib::Uri.new(type: type, content: args[0])
+        end
+      else
+        super
+      end
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity, Style/MissingRespondToMissing
+  end
+end

data/lib/relaton/bipm/data_outcomes_parser.rb

@@ -94,9 +94,14 @@ module Relaton::Bipm
         @data_fetcher.write_file path, has_part_item, warn_duplicate: false
         path = File.join dir, "#{num}-#{part}.#{@data_fetcher.ext}"
       elsif part
-        hash[:title].each { |t| t.content.sub!(/\s\(.+\)$/, "") }
+        # The part item keeps the full titles ("… (Session I)"); the base
+        # item's titles drop the parenthetical. Assign the stripped form -
+        # `Title#content` exposes the source metadata string, and a
+        # mutating `sub!` would strip the part item's title too (the two
+        # share the string object).
         h = meeting_bibitem body: body, type: type, en: en_md, fr: fr_md, num: num, src: src, pdf: en["pdf"]
         add_part h, body, type, num, part
+        hash[:title].each { |t| t.content = t.content.sub(/\s\(.+\)$/, "") }
         part_item = ItemData.new(**h)
         part_item_path = File.join dir, "#{num}-#{part}.#{@data_fetcher.ext}"
         @data_fetcher.write_file part_item_path, part_item

data/lib/relaton/cli/base_convertor.rb

@@ -0,0 +1,134 @@
+require "fileutils"
+require "relaton/bibdata"
+require "relaton/bibcollection"
+require "relaton/cli/xml_to_html_renderer"
+
+module Relaton
+  module Cli
+    class BaseConvertor
+      def initialize(file, options = {})
+        @file = file
+        @options = options
+        @outdir = options.fetch(:outdir, nil)
+        @writable = options.fetch(:write, true)
+        @overwrite = options.fetch(:overwrite, true)
+        @default_filelabel = 0
+
+        install_dependencies(options[:require] || [])
+      end
+
+      # @return [String] HTML
+      def to_html
+        content = convert_to_html
+        write_to_a_file(content)
+      end
+
+      # Convert to HTML
+      #
+      # This interface expect us to provide Relaton collection XML
+      # as XML/RXL, and necessary styels / templates then it will be
+      # used convert that collection to HTML.
+      #
+      # @param file [String] Relaton collection file path
+      # @param style [String] Stylesheet file path for styles
+      # @param template [String] The liquid tempalte directory
+      #
+      # @return [String] HTML
+      def self.to_html(file, style = nil, template = nil)
+        new(
+          file,
+          style: style || File.join(File.dirname(__FILE__), "templates/index-style.css"),
+          template: template || File.join(File.dirname(__FILE__), "templates/"),
+          extension: "html"
+        ).to_html
+      end
+
+      private
+
+      attr_reader :file, :outdir, :options, :writable, :overwrite
+
+      # @return [String] HTML
+      def convert_to_html
+        Relaton::Cli::XmlToHtmlRenderer.render(
+          xml_content(file),
+          stylesheet: options[:style],
+          liquid_dir: options[:template]
+        )
+      end
+
+      # @param file [String] path to a file
+      # @return [String] the file's content
+      # @return [String] HTML
+      def xml_content(file)
+        File.read(file, encoding: "utf-8")
+      end
+
+      def install_dependencies(dependencies)
+        dependencies.each { |dependency| require(dependency) }
+      end
+
+      def item_output(content, format)
+        case format.to_sym
+        when :to_yaml then content.to_yaml
+        when :to_xml then content.to_xml(date_format: :full, bibdata: true)
+        end
+      end
+
+      def convert_and_write(content, format)
+        content = convert_content(content)
+        write_to_a_file(item_output(content, format))
+        write_to_file_collection(content, format.to_sym)
+      end
+
+      def write_to_a_file(content, outfile = nil)
+        outfile ||= Pathname.new(file).sub_ext(extension).to_s
+
+        if !File.exist?(outfile) || overwrite
+          File.open(outfile, "w:utf-8") do |file|
+            file.write(content)
+          end
+        end
+      end
+
+      def write_to_file_collection(content, format)
+        if outdir && content.is_a?(Relaton::Bibcollection)
+          FileUtils.mkdir_p(outdir)
+          content.items_flattened.each do |item|
+            collection = collection_filename(extract_docid(item))
+            write_to_a_file(item_output(item, format), collection)
+          end
+        end
+      end
+
+      def extract_docid(item)
+        @default_filelabel += 1
+        item.docidentifier.nil? && (return @default_filelabel.to_s)
+        # item.docidentifier.is_a?(Array) or return @default_filelabel.to_s
+        item.docidentifier.empty? && (return @default_filelabel.to_s)
+        docidentifier_code(item.docidentifier)
+      end
+
+      # From http://gavinmiller.io/2016/creating-a-secure-sanitization-function/
+      FILENAME_BAD_CHARS = ["/", '\\', "?", '%", "*", ":', "|", '"', "<", ">",
+                            ".", " "].freeze
+
+      def docidentifier_code(docidentifier)
+        return "" if docidentifier.nil?
+
+        FILENAME_BAD_CHARS.reduce(docidentifier.downcase) do |result, bad_char|
+          result.gsub(bad_char, "-")
+        end
+      end
+
+      def extension
+        @extension ||= [".", options.fetch(:extension, default_ext)].join
+      end
+
+      def collection_filename(identifier)
+        File.join(
+          outdir, [@options[:prefix], identifier, extension].compact.join("")
+        )
+      end
+    end
+  end
+end