relaton-cli 3.0.7 → 3.1.0

data/lib/relaton/cli/relaton_file.rb

@@ -1,290 +0,0 @@
-require "nokogiri"
-require "pathname"
-
-module Relaton
-  module Cli
-    class RelatonFile
-      def initialize(source, options = {})
-        @source = source
-        @options = options
-        @outdir = options.fetch(:outdir, nil)
-        @outfile = options.fetch(:outfile, nil)
-      end
-
-      def extract
-        extract_and_write_to_files
-      end
-
-      def concatenate
-        concatenate_and_write_to_files
-      end
-
-      def split
-        split_and_write_to_files
-      end
-
-      # Extract files
-      #
-      # This interface expect us to provide a source file / directory,
-      # output directory and custom configuration options. Then it wll
-      # extract Relaton XML file / files to output directory from the
-      # source file / directory. During this process it will use custom
-      # options when available.
-      #
-      # @param source [Dir] The source directory for files
-      # @param outdir [Dir] The output directory for files
-      # @param options [Hash] Options as hash key value pair
-      #
-      def self.extract(source, outdir, options = {})
-        new(source, options.merge(outdir: outdir)).extract
-      end
-
-      # Concatenate files
-      #
-      # This interface expect us to provide a source directory, output
-      # file and custom configuration options. Normally, this expect the
-      # source directory to contain RXL fles, but it also converts any
-      # YAML files to RXL and then finally combines those together.
-      #
-      # This interface also allow us to provdie options like title and
-      # organization and then it usage those details to generate the
-      # collection file.
-      #
-      # @param source [Dir] The source directory for files
-      # @param output [String] The collection output file
-      # @param options [Hash] Options as hash key value pair
-      #
-      def self.concatenate(source, outfile, options = {})
-        new(source, options.merge(outfile: outfile)).concatenate
-      end
-
-      # Split collection
-      #
-      # This interface expects us to provide a Relaton Collection
-      # file and also an output directory, then it will split that
-      # collection into multiple files.
-      #
-      # By default it usages `rxl` extension for these new files,
-      # but we can also customize that by providing the correct
-      # one as `extension` option parameter.
-      #
-      # @param source [File] The source collection file
-      # @param output [Dir] The output directory for files
-      # @param options [Hash] Options as hash key value pair
-      #
-      def self.split(source, outdir = nil, options = {})
-        new(source, options.merge(outdir: outdir)).split
-      end
-
-      private
-
-      attr_reader :source, :options, :outdir, :outfile
-
-      def bibcollection
-        Bibcollection.new(
-          title: options[:title],
-          items: concatenate_files,
-          doctype: options[:doctype],
-          author: options[:organization],
-        )
-      end
-
-      # Turn an XML string into a Nokogiri XML document.
-      #
-      # @param document [String] XML
-      # @param file [String, nil] path to file
-      # @return [Nokogiri::XML::Document]
-      def nokogiri_document(document, file = nil)
-        document ||= File.read(file, encoding: "utf-8")
-        Nokogiri.XML(document)
-      end
-
-      def select_source_files
-        if File.file?(source)
-          [source]
-        else
-          select_files_with("xml")
-        end
-      end
-
-      def relaton_collection
-        @relaton_collection ||= Bibcollection.from_xml(nokogiri_document(nil, source))
-      end
-
-      def extract_and_write_to_files # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-        select_source_files.each do |file|
-          xml = nokogiri_document(nil, file)
-          xml.remove_namespaces!
-
-          if (bib = xml.at("//bibdata"))
-            bib = nokogiri_document(bib.to_xml)
-          elsif (rfc = xml.at("//rfc"))
-            require "relaton/ietf"
-            require "relaton/ietf/bibxml_parser"
-            ietf = Relaton::Ietf::BibXMLParser.parse_rfc rfc.to_xml
-            bib = nokogiri_document(ietf.to_xml(bibdata: true))
-          else
-            next
-          end
-
-          bib.remove_namespaces!
-
-          bibdata = Relaton::Bibdata.from_xml(bib.root)
-          if bibdata
-            build_bibdata_relaton(bibdata, file)
-
-            write_to_file(bibdata.send(output_type), outdir, build_filename(file))
-          end
-        end
-      end
-
-      # Map all relevant files to the corresponding bibdata instances
-      #
-      # @return [Array<Relaton::Bibdata>]
-      def concatenate_files
-        xml_files = [convert_rxl_to_xml, convert_yamls_to_xml, convert_xml_to_xml]
-
-        xml_files.flatten.reduce([]) do |mem, xml|
-          doc = nokogiri_document(xml[:content])
-          if (rfc = doc.at("/rfc"))
-            require "relaton/ietf"
-            require "relaton/ietf/bibxml_parser"
-            ietf = Relaton::Ietf::BibXMLParser.parse_rfc rfc.to_xml
-            d = nokogiri_document ietf.to_xml(bibdata: true)
-            mem << bibdata_instance(d, xml[:file])
-          elsif %w[bibitem bibdata].include? doc&.root&.name
-            mem << bibdata_instance(doc, xml[:file])
-          else mem
-          end
-        end
-      end
-
-      def concatenate_and_write_to_files
-        write_to_file(bibcollection.send(output_type))
-      end
-
-      def split_and_write_to_files
-        output_dir = outdir || build_dirname(source)
-
-        relaton_collection.items.each do |content|
-          name = build_filename(nil, content.docidentifier)
-          find_available_bibrxl_file(name, output_dir, content)
-          write_to_file(content.send(output_type), output_dir, name)
-        end
-      end
-
-      def find_available_bibrxl_file(name, _ouputdir, content)
-        if options[:extension] == "yaml" || options[:extension] == "yml"
-          bib_rxl = Pathname.new([outdir, name].join("/")).sub_ext(".rxl")
-          content.bib_rxl = bib_rxl.to_s if File.file?(bib_rxl)
-        end
-      end
-
-      def output_type(ext = options[:extension])
-        ext ||= File.extname(outfile)[1..-1] if outfile
-        case ext
-        when "rxl", "xml"
-          :to_xml
-        when "yml", "yaml"
-          :to_yaml
-        else
-          puts "[relaton-cli] the given extension of '#{ext}' is "\
-          "not supported. Use 'rxl'."
-          :to_xml
-        end
-      end
-
-      # Create a bibdata instance from the XML document,
-      # while also adding file paths of related artifacts
-      # as URI elements to the bibdata instance.
-      #
-      # @param document [Nokogiri::XML::Document]
-      # @param file [String] path to file
-      # @return [Relaton::Bibdata]
-      def bibdata_instance(document, file)
-        document = clean_nokogiri_document(document)
-        bibdata = Relaton::Bibdata.from_xml document.root
-        build_bibdata_relaton(bibdata, file) if bibdata
-
-        bibdata
-      end
-
-      # For each file type, add to the bibdata:
-      #   - a URI element that points to the file of that file type
-      #
-      # The URI element generation is skipped if the file does not exist.
-      #
-      # @param bibdata [Relaton::Bibdata]
-      # @param file [String] path to file
-      def build_bibdata_relaton(bibdata, file)
-        ["xml", "pdf", "doc", "html", "rxl", "txt"].each do |type|
-          file = Pathname.new(file).sub_ext(".#{type}")
-          bibdata.send("#{type}=", file.to_s) if File.file?(file)
-        end
-      end
-
-      # Force a namespace otherwise Nokogiri won't parse.
-      # The reason is we use Bibcollection's from_xml, but that one
-      # has an xmlns. We don't want to change the code for bibdata
-      # hence this hack #bibdata_doc.root['xmlns'] = "xmlns"
-      #
-      # @param document [Nokogiri::XML::Document]
-      # @return [Nokogiri::XML::Document]
-      def clean_nokogiri_document(document)
-        document.remove_namespaces!
-        nokogiri_document(document.to_xml)
-      end
-
-      def convert_rxl_to_xml
-        select_files_with("{rxl}").map do |file|
-          { file: file, content: File.read(file, encoding: "utf-8") }
-        end
-      end
-
-      def convert_yamls_to_xml
-        select_files_with("yaml").map do |file|
-          { file: file, content: YAMLConvertor.to_xml(file, write: false) }
-        end
-      end
-
-      def convert_xml_to_xml
-        select_files_with("{xml}").map do |file|
-          { file: file, content: File.read(file, encoding: "utf-8") }
-        end
-      end
-
-      def select_files_with(extension)
-        files = File.join(source, "**", "*.#{extension}")
-        Dir[files].reject { |file| File.directory?(file) }
-      end
-
-      def write_to_file(content, directory = nil, output_file = nil)
-        file_with_dir = [directory, output_file || outfile].compact.join("/")
-        File.open(file_with_dir, "w:utf-8") { |file| file.write(content) }
-      end
-
-      def build_dirname(filename)
-        basename = File.basename(filename)&.gsub(/.(xml|rxl)/, "")
-        directory_name = sanitize_string(basename)
-        FileUtils.mkdir_p(directory_name) # unless File.exists?(directory_name)
-
-        directory_name
-      end
-
-      def build_filename(file, identifier = nil, ext = "rxl")
-        identifier ||= Pathname.new(File.basename(file.to_s, ".xml")).to_s
-        [sanitize_string(identifier), options[:extension] || ext].join(".")
-      end
-
-      def sanitize_string(string)
-        clean_string = replace_bad_characters(string.downcase)
-        clean_string.gsub(/^\s+/, "").gsub(/\s+$/, "").gsub(/\s+/, "-")
-      end
-
-      def replace_bad_characters(string)
-        bad_chars = ["/", "\\", "?", "%", "*", ":", "|", '"', "<", ">", ".", " "]
-        bad_chars.reduce(string.downcase) { |res, char| res.gsub(char, "-") }
-      end
-    end
-  end
-end

data/lib/relaton/cli/subcommand_collection.rb

@@ -1,263 +0,0 @@
-require "pubid"
-require "relaton/cli/full_text_search"
-
-module Relaton
-  module Cli
-    class SubcommandCollection < Thor
-      include Relaton::Cli
-      class_option :verbose, aliases: :v, type: :boolean, desc: "Output warnings"
-
-      desc "create COLLECTION", "Create collection"
-      option :dir, aliases: :d, desc: "Directory to store collection. " \
-                                      "Default is $HOME/.relaton/collections."
-      option :author, desc: "Author"
-      option :title, desc: "Title"
-      option :doctype, desc: "Documents type"
-
-      def create(file)
-        dir = directory
-        file_path = File.join dir, file
-        col = Relaton::Bibcollection.new options
-        if File.exist? file_path
-          Util.warn "Collection `#{file}` aready exist"
-        else
-          FileUtils.mkdir_p dir # unless Dir.exist? dir
-          File.write file_path, col.to_yaml, encoding: "UTF-8"
-        end
-      end
-
-      desc "info COLLECTION", "View collection information"
-      option :dir, aliases: :d, desc: "Directory to store collection. " \
-                                      "Default is $HOME/.relaton/collections."
-
-      def info(file) # rubocop:disable Metrics/AbcSize
-        path = File.join directory, file
-        puts "Collection: #{File.basename path}"
-        puts "Last updated: #{File.mtime path}"
-        puts "File size: #{File.size path}"
-        col = Relaton::Bibcollection.new YAML.load_file(path)["root"]
-        puts "Number of items: #{col.items.size}"
-        puts "Author: #{col.author}"
-        puts "Title: #{col.title}"
-      end
-
-      desc "list", "List collections"
-      option :dir, aliases: :d, desc: "Directory with collections. Default " \
-                                      "is $HOME/.relaton/collections."
-      option :entries, aliases: :e, type: :boolean, desc: "Show entries"
-
-      def list
-        Dir[File.join(directory, "*")].each do |f|
-          yml = read_yaml f
-          if yml && yml["root"]
-            puts File.basename f
-            puts_entries yml
-          end
-        end
-      end
-
-      map ls: :list
-
-      desc "get CODE", "Fetch document from collection by ID"
-      option :collection, aliases: :c, desc: "Collection to fetch document. " \
-        "By default fetch the first match across all collections."
-      option :dir, aliases: :d, desc: "Directory with collections. Default " \
-                                      "is $HOME/.relaton/collections."
-      option :format, aliases: :f, desc: "Output format (xml, abb). " \
-        "If not defined the output in a human-readable form."
-      option :output, aliases: :o, desc: "Output to the specified file. The " \
-        " file's extension (abb, xml) defines output format."
-
-      def get(docid)
-        collections.each do |col|
-          col[:collection].items.each do |item|
-            if item.docidentifier == docid
-              output_item(item)
-              return
-            end
-          end
-        end
-      end
-
-      desc "find TEXT", "Full-text search"
-      option :collection, aliases: :c, desc: "Collection to search text. " \
-        "By default search across all collections."
-      option :dir, aliases: :d, desc: "Directory with collections. Default is " \
-                                      "$HOME/.relaton/collections."
-
-      def find(text)
-        collections.each do |col|
-          searcher = Relaton::FullTextSeatch.new(col[:collection])
-          searcher.search text
-          if searcher.any?
-            puts "Collection: #{File.basename(col[:file])}"
-            searcher.print_results
-          end
-        end
-      end
-
-      map search: :find
-
-      desc "fetch CODE", "Fetch a document and store it into a collection"
-      option :type, aliases: :t, required: true,
-                    desc: "Type of standard to get bibliographic entry for"
-      option :year, aliases: :y, type: :numeric,
-                    desc: "Year the standard was published"
-      option :"publication-date-before",
-        desc: "Fetch only documents published before the specified date " \
-          "(e.g. 2008, 2008-02, or 2008-02-02)"
-      option :"publication-date-after",
-        desc: "Fetch only documents published after the specified date " \
-          "(e.g. 2002, 2002-01, or 2002-01-01)"
-      option :collection, aliases: :c, required: true,
-                          desc: "Collection to store a document"
-      option :dir, aliases: :d, desc: "Directory with collections. Default is " \
-                                      "$HOME/.relaton/collections."
-
-      def fetch(code) # rubocop:disable Metrics/AbcSize
-        opts = {}
-        if options[:"publication-date-before"]
-          opts[:publication_date_before] = parse_date_option(options[:"publication-date-before"], "--publication-date-before")
-        end
-        if options[:"publication-date-after"]
-          opts[:publication_date_after] = parse_date_option(options[:"publication-date-after"], "--publication-date-after")
-        end
-        validate_date_range opts[:publication_date_after], opts[:publication_date_before]
-        doc = Relaton.db.fetch(code, options[:year]&.to_s, **opts)
-        if doc
-          colfile = File.join directory, options[:collection]
-          coll = read_collection colfile
-          coll << doc
-          File.write colfile, coll.to_yaml, encoding: "UTF-8"
-        else Util.info "No matching bibliographic entry found"
-        end
-      rescue Relaton::UnknownReferenceError => e
-        Util.warn e.message
-      rescue Pubid::Errors::Error
-        Util.error %("#{code}" is not a recognized standards identifier)
-      end
-
-      desc "import FILE", "Import document or collection from an XML file " \
-                          "into another collection"
-      option :collection, aliases: :c, required: true,
-                          desc: "Collection to store a document. If " \
-                                "collection doesn't exist then it'll be created."
-      option :dir, aliases: :d, desc: "Directory with collections. Default is " \
-                                      "$HOME/.relaton/collections."
-
-      def import(file) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-        collfile = File.join directory, options[:collection]
-        coll = read_collection collfile
-        xml = Nokogiri::XML File.read(file, encoding: "UTF-8")
-        xml.remove_namespaces!
-        if xml.at "relaton-collection"
-          imported = import_collection(xml)
-          if coll
-            coll << imported
-          else
-            coll = imported
-          end
-        else
-          coll ||= Relaton::Bibcollection.new({})
-          coll << Relaton::Bibdata.from_xml(xml)
-        end
-        File.write collfile, coll.to_yaml, encoding: "UTF-8"
-      end
-
-      desc "export COLLECTION", "Export collection into XML file"
-      option :dir, aliases: :d, desc: "Directory with collections. Default is " \
-                                      "$HOME/.relaton/collections."
-
-      def export(file)
-        coll = read_collection File.join(directory, file)
-        outfile = "#{file.sub(/\.\w+$/, '')}.xml"
-        File.write outfile, coll.to_xml(bibdata: true), encoding: "UTF-8"
-      end
-
-      private
-
-      # Parse a namespace-free collection XML document.
-      # Bibcollection.from_xml expects namespaced docs (via apply_namespace),
-      # so we use plain XPath on the namespace-stripped document instead.
-      def import_collection(xml)
-        title = xml.at("relaton-collection/title")&.text
-        author = xml.at_xpath(
-          "./relaton-collection/contributor[role/@type='author']"\
-          "/organization/name",
-        )&.text
-        items = xml.xpath("relaton-collection/relation").map do |rel|
-          el = rel.at("bibdata") || rel.at("bibitem")
-          Relaton::Bibdata.from_xml(el || rel)
-        end.compact
-        Relaton::Bibcollection.new(title: title, author: author, items: items)
-      end
-
-      # @return [String]
-      def directory
-        options.fetch :dir, File.join(Dir.home, ".relaton/collections")
-      end
-
-      # @param file [String]
-      # @return [Hash, nil]
-      def read_yaml(file)
-        YAML.load_file file if File.file? file
-      rescue Psych::SyntaxError
-        Util.error "the file `#{file}` isn't a collection."
-        nil
-      end
-
-      # @param file [String]
-      # @return [Relaton::Bibcollection, nil]
-      def read_collection(file)
-        return unless File.file?(file)
-
-        Relaton::Bibcollection.new YAML.load_file(file)["root"]
-      end
-
-      # @return [Array<Hash>]
-      def collections
-        file = options.fetch :collection, "*"
-        Dir[File.join directory, file].reduce([]) do |m, f|
-          yml = read_yaml f
-          if yml && yml["root"]
-            m << { collection: Relaton::Bibcollection.new(yml["root"]),
-                   file: f }
-          end
-          m
-        end
-      end
-
-      # Puts document IDs for each item in tthe cokllection
-      # @param hash [Hash] Relaton collection
-      def puts_entries(hash)
-        return unless options[:entries]
-
-        Relaton::Bibcollection.new(hash["root"]).items.each do |b|
-          puts "  #{b.docidentifier}"
-        end
-      end
-
-      # @param item [Relaton::Bibdata]
-      def output_item(item)
-        case options[:format]
-        when "xml" then puts item.to_xml bibdata: true
-        when "abb" then puts item.to_asciibib
-        else puts_human_readable_item item
-        end
-        out = case options[:output]
-              when /\.abb$/ then item.to_asciibib
-              when /\.xml$/ then item.to_xml bibitem: true
-              end
-        File.write options[:output], out, encoding: "UTF-8" if out
-      end
-
-      # @param item [Relaton::Bibdata]
-      def puts_human_readable_item(item) # rubocop:disable Metrics/AbcSize
-        puts "Document identifier: #{item.docidentifier}"
-        puts "Title: #{item.title.first.content}"
-        puts "Status: #{item.status.stage}"
-        item.date.each { |d| puts "Date #{d.type}: #{d.at || d.from}" }
-      end
-    end
-  end
-end

data/lib/relaton/cli/subcommand_db.rb

@@ -1,81 +0,0 @@
-module Relaton
-  module Cli
-    class SubcommandDb < Thor
-      include Relaton::Cli
-      class_option :verbose, aliases: :v, type: :boolean, desc: "Output warnings"
-
-      desc "create DIR", "Create new cache DB. Default DIR is " \
-                         "/home/user/.relaon/cache/"
-
-      def create(dir = nil)
-        db = Relaton.db (dir && File.expand_path(dir))
-        path = db.instance_variable_get(:@db).dir
-        Util.warn "Cache DB is in `#{path}`"
-      end
-
-      desc "mv DIR", "Move cache DB to a new directory"
-
-      def mv(dir)
-        new_path = File.expand_path dir
-        path = Relaton.db.mv new_path
-        if path
-          File.write Cli::RelatonDb::DBCONF, path, encoding: "UTF-8"
-          Util.warn "Cache DB is moved to `#{path}`"
-        end
-      end
-
-      desc "clear", "Clear cache DB"
-
-      def clear
-        db = Relaton.db
-        db.clear
-        Util.warn "Cache DB is cleared"
-      end
-
-      desc "fetch CODE", "Fetch Relaton XML for Standard identifier CODE " \
-                         "from cache DB"
-      option :type, aliases: :t, desc: "Type of standard to " \
-                                       "get bibliographic entry for"
-      option :format, aliases: :f, desc: "Output format (xml, yaml, bibtex). " \
-                                         "Default xml."
-      option :year, aliases: :y, type: :numeric, desc: "Year the standard " \
-                                                       "was published"
-      option :"publication-date-before",
-        desc: "Fetch only documents published before the specified date " \
-          "(e.g. 2008, 2008-02, or 2008-02-02)"
-      option :"publication-date-after",
-        desc: "Fetch only documents published after the specified date " \
-         "(e.g. 2002, 2002-01, or 2002-01-01)"
-
-      def fetch(code)
-        io = IO.new($stdout.fcntl(::Fcntl::F_DUPFD), mode: "w:UTF-8")
-        opts = options.merge(fetch_db: true)
-        io.puts(fetch_document(code, opts) || supported_type_message)
-      end
-
-      desc "fetch_all TEXT", "Query for all documents in a cache DB for a " \
-                             "certain string"
-      option :edition, aliases: :e, desc: "Filter entries by edition"
-      option :year, aliases: :y, desc: "Filter entries by year"
-      option :format, aliases: :f, desc: "Output format (xml, yaml, bibtex). " \
-                                         "Default xml."
-
-      def fetch_all(text = nil) # rubocop:disable Metrics/AbcSize
-        io = IO.new($stdout.fcntl(::Fcntl::F_DUPFD), mode: "w:UTF-8")
-        opts = options.each_with_object({}) do |(k, v), o|
-          o[k.to_sym] = v unless k == "format"
-        end
-        Relaton.db.fetch_all(text, **opts).each do |doc|
-          io.puts serialize(doc, options[:format])
-        end
-      end
-
-      desc "doctype REF", "Detect document type from REF"
-
-      def doctype(ref)
-        io = IO.new($stdout.fcntl(::Fcntl::F_DUPFD), mode: "w:UTF-8")
-        io.puts Relaton.db.docid_type(ref)
-      end
-    end
-  end
-end

data/lib/relaton/cli/util.rb

@@ -1,8 +0,0 @@
-module Relaton
-  module Cli
-    module Util
-      extend Relaton::Bib::Util
-      PROGNAME = "relaton-cli".freeze
-    end
-  end
-end

data/lib/relaton/cli/version.rb

@@ -1,11 +0,0 @@
-# relaton-cli ships in lockstep with the combined `relaton` gem, so its version
-# is that gem's version — the single source of truth in Relaton::VERSION. relaton
-# is a hard runtime dependency, so requiring its lightweight version file always
-# resolves. Don't hardcode a string here; it would silently drift on a bump.
-require "relaton/version"
-
-module Relaton
-  module Cli
-    VERSION = Relaton::VERSION
-  end
-end