relaton-cli 1.4.0 → 1.7.pre3

data/lib/relaton/cli.rb

@@ -3,53 +3,92 @@ require "relaton"
 require_relative "cli/command"
 
 module Relaton
-  def self.db
-    Cli.relaton
+  def self.db(dir = nil)
+    Cli.relaton dir
   end
 
   module Cli
     class RelatonDb
       include Singleton
 
-      def db
-        @db ||= Relaton::Db.new("#{Dir.home}/.relaton/cache", nil)
+      DBCONF = "#{Dir.home}/.relaton/dbpath".freeze
+
+      # @param dir [String, nil]
+      # @return [Relaton::Db]
+      def db(dir)
+        if dir
+          File.write DBCONF, dir, encoding: "UTF-8"
+          @db = Relaton::Db.new dir, nil
+        else
+          @db ||= Relaton::Db.new dbpath, nil
+        end
       end
-    end
 
-    def self.start(arguments)
-      Relaton::Cli::Command.start(arguments)
-    end
+      private
 
-    # Relaton
-    #
-    # Based on current setup, we need to initiate a Db instance to
-    # register all of it's supported processor backends. To make it
-    # easier we have added it as a class method so we can use this
-    # whenever necessary.
-    #
-    def self.relaton
-      RelatonDb.instance.db
+      # @return [String] path to DB
+      def dbpath
+        if File.exist?(DBCONF)
+          File.read(DBCONF, encoding: "UTF-8")
+        else "#{Dir.home}/.relaton/cache"
+        end
+      end
     end
 
-    # @param content [Nokogiri::XML::Document]
-    # @return [RelatonBib::BibliographicItem, RelatonIsoBib::IsoBibliongraphicItem]
-    def self.parse_xml(doc)
-      if (proc = Cli.processor(doc))
-        proc.from_xml(doc.to_s)
-      else
-        RelatonBib::XMLParser.from_xml(doc.to_s)
+    class << self
+      def start(arguments)
+        Relaton::Cli::Command.start(arguments)
+      end
+
+      # Relaton
+      #
+      # Based on current setup, we need to initiate a Db instance to
+      # register all of it's supported processor backends. To make it
+      # easier we have added it as a class method so we can use this
+      # whenever necessary.
+      #
+      # @param dir [String, nil]
+      # @return [Relaton::Db]
+      def relaton(dir)
+        RelatonDb.instance.db dir
       end
-    end
 
-    # @param doc [Nokogiri::XML::Element]
-    # @return [String] Type prefix
-    def self.processor(doc)
-      docid = doc.at "docidentifier"
-      if docid && docid[:type]
-        proc = Relaton::Registry.instance.by_type(docid[:type])
+      # @param content [Nokogiri::XML::Document]
+      # @return [RelatonBib::BibliographicItem,
+      #   RelatonIsoBib::IsoBibliongraphicItem]
+      def parse_xml(doc)
+        if (proc = Cli.processor(doc))
+          proc.from_xml(doc.to_s)
+        else
+          RelatonBib::XMLParser.from_xml(doc.to_s)
+        end
+      end
+
+      # @param doc [Nokogiri::XML::Element]
+      # @return [RelatonIso::Processor, RelatonIec::Processor,
+      #   RelatonNist::Processor, RelatonIetf::Processot,
+      #   RelatonItu::Processor, RelatonGb::Processor,
+      #   RelatonOgc::Processor, RelatonCalconnect::Processor]
+      def processor(doc)
+        docid = doc.at "docidentifier"
+        proc = get_proc docid
         return proc if proc
+
+        Relaton::Registry.instance.by_type(docid&.text&.match(/^\w+/)&.to_s)
+      end
+
+      private
+
+      # @param doc [Nokogiri::XML::Element]
+      # @return [RelatonIso::Processor, RelatonIec::Processor,
+      #   RelatonNist::Processor, RelatonIetf::Processot,
+      #   RelatonItu::Processor, RelatonGb::Processor,
+      #   RelatonOgc::Processor, RelatonCalconnect::Processor]
+      def get_proc(docid)
+        return unless docid && docid[:type]
+
+        Relaton::Registry.instance.by_type(docid[:type])
       end
-      Relaton::Registry.instance.by_type(docid&.text&.match(/^\w+/)&.to_s)
     end
   end
 end

data/lib/relaton/cli/base_convertor.rb

@@ -52,7 +52,7 @@ module Relaton
         Relaton::Cli::XmlToHtmlRenderer.render(
           xml_content(file),
           stylesheet: options[:style],
-          liquid_dir: options[:template],
+          liquid_dir: options[:template]
         )
       end
 

data/lib/relaton/cli/command.rb

@@ -1,93 +1,136 @@
 require "relaton/cli/relaton_file"
 require "relaton/cli/xml_convertor"
 require "relaton/cli/yaml_convertor"
+require "relaton/cli/subcommand_collection"
+require "relaton/cli/subcommand_db"
 require "fcntl"
 
 module Relaton
   module Cli
     class Command < Thor
+      include Relaton::Cli
+
       desc "fetch CODE", "Fetch Relaton XML for Standard identifier CODE"
-      option :type, aliases: :t, required: true, desc: "Type of standard to get bibliographic entry for"
-      option :format, aliases: :f, desc: "Output format (xml, bibtex). Default xml."
-      option :year, aliases: :y, type: :numeric, desc: "Year the standard was published"
+      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 :"all-parts", type: :boolean, desc: "Fetch all parts"
+      option :"keep-year", type: :boolean, desc: "Undated reference should "\
+        "return actual reference with year"
+      option :retries, aliases: :r, type: :numeric, desc: "Number of network "\
+        "retries. Default 1."
 
       def fetch(code)
-        Relaton.db
-        io = IO.new(STDOUT.fcntl(::Fcntl::F_DUPFD), mode: 'w:UTF-8')
+        # Relaton.db
+        io = IO.new(STDOUT.fcntl(::Fcntl::F_DUPFD), mode: "w:UTF-8")
         io.puts(fetch_document(code, options) || supported_type_message)
       end
 
-      desc "extract Metanorma-XML-File / Directory Relaton-XML-Directory", "Extract Relaton XML from Metanorma XML file / directory"
-      option :extension, aliases: :x, default: "rxl", desc: "File extension of Relaton XML files, defaults to 'rxl'"
+      desc "extract Metanorma-XML-File / Directory Relaton-XML-Directory",
+           "Extract Relaton XML from Metanorma XML file / directory"
+      option :extension, aliases: :x, default: "rxl", desc: "File extension "\
+        "of Relaton XML files, defaults to 'rxl'"
 
       def extract(source_dir, outdir)
         Relaton::Cli::RelatonFile.extract(source_dir, outdir, options)
       end
 
-      desc "concatenate SOURCE-DIR COLLECTION-FILE", "Concatenate entries in DIRECTORY (containing Relaton-XML or YAML) into a Relaton Collection"
+      desc "concatenate SOURCE-DIR COLLECTION-FILE", "Concatenate entries in "\
+        "DIRECTORY (containing Relaton-XML or YAML) into a Relaton Collection"
       option :title, aliases: :t,  desc: "Title of resulting Relaton collection"
-      option :organization, aliases: :g, desc: "Organization owner of Relaton collection"
-      option :new, aliases: :n, type: :boolean, desc: "Use the new Relaton YAML format"
-      option :extension, aliases: :x, desc: "File extension of destination Relaton file, defaults to 'rxl'"
+      option :organization, aliases: :g, desc: "Organization owner of Relaton "\
+        "collection"
+      # option :new, aliases: :n, type: :boolean, desc: "Use the new Relaton "\
+      #   "YAML format"
+      option :extension, aliases: :x, desc: "File extension of destination "\
+        "Relaton file, defaults to 'rxl'"
 
       def concatenate(source_dir, outfile)
         Relaton::Cli::RelatonFile.concatenate(source_dir, outfile, options)
       end
 
-      desc "split Relaton-Collection-File Relaton-XML-Directory", "Split a Relaton Collection into multiple files"
-      option :extension, aliases: :x, default: "rxl", desc: "File extension of Relaton XML files, defaults to 'rxl'"
-      option :new, aliases: :n, type: :boolean, desc: "Use the new Relaton YAML format"
+      desc "split Relaton-Collection-File Relaton-XML-Directory", "Split a "\
+        "Relaton Collection into multiple files"
+      option :extension, aliases: :x, default: "rxl", desc: "File extension "\
+        "of Relaton XML files, defaults to 'rxl'"
+      # option :new, aliases: :n, type: :boolean, desc: "Use the new Relaton "\
+      #   "YAML format"
 
       def split(source, outdir)
         Relaton::Cli::RelatonFile.split(source, outdir, options)
       end
 
-      desc "yaml2xml YAML", "Convert Relaton YAML into Relaton Collection XML or separate files"
-      option :extension, aliases: :x, default: "rxl", desc: "File extension of Relaton XML files, defaults to 'rxl'"
-      option :prefix, aliases: :p, desc: "Filename prefix of individual Relaton XML files, defaults to empty"
-      option :outdir, aliases: :o, desc: "Output to the specified directory with individual Relaton Bibdata XML files"
-      option :require, aliases: :r, type: :array, desc: "Require LIBRARY prior to execution"
-      option :overwrite, aliases: :f, type: :boolean, default: false, desc: "Overwrite the existing file"
+      desc "yaml2xml YAML", "Convert Relaton YAML into Relaton Collection XML "\
+        "or separate files"
+      option :extension, aliases: :x, default: "rxl", desc: "File extension "\
+        "of Relaton XML files, defaults to 'rxl'"
+      option :prefix, aliases: :p, desc: "Filename prefix of individual "\
+        "Relaton XML files, defaults to empty"
+      option :outdir, aliases: :o, desc: "Output to the specified directory "\
+        "with individual Relaton Bibdata XML files"
+      option :require, aliases: :r, type: :array, desc: "Require LIBRARY "\
+        "prior to execution"
+      option :overwrite, aliases: :f, type: :boolean, default: false,
+                         desc: "Overwrite the existing file"
 
       def yaml2xml(filename)
         Relaton::Cli::YAMLConvertor.to_xml(filename, options)
       end
 
-      desc "xml2yaml XML", "Convert Relaton XML into Relaton Bibdata / Bibcollection YAML (and separate files)"
-      option :extension, aliases: :x, default: "yaml", desc: "File extension of Relaton YAML files, defaults to 'yaml'"
-      option :prefix, aliases: :p, desc: "Filename prefix of Relaton XML files, defaults to empty"
-      option :outdir, aliases: :o, desc: "Output to the specified directory with individual Relaton Bibdata YAML files"
-      option :require, aliases: :r, type: :array, desc: "Require LIBRARY prior to execution"
-      option :overwrite, aliases: :f, type: :boolean, default: false, desc: "Overwrite the existing file"
+      desc "xml2yaml XML", "Convert Relaton XML into Relaton Bibdata / "\
+        "Bibcollection YAML (and separate files)"
+      option :extension, aliases: :x, default: "yaml", desc: "File extension "\
+        "of Relaton YAML files, defaults to 'yaml'"
+      option :prefix, aliases: :p, desc: "Filename prefix of Relaton XML "\
+        "files, defaults to empty"
+      option :outdir, aliases: :o, desc: "Output to the specified directory "\
+        "with individual Relaton Bibdata YAML files"
+      option :require, aliases: :r, type: :array, desc: "Require LIBRARY "\
+        "prior to execution"
+      option :overwrite, aliases: :f, type: :boolean, default: false,
+                         desc: "Overwrite the existing file"
 
       def xml2yaml(filename)
         Relaton::Cli::XMLConvertor.to_yaml(filename, options)
       end
 
-      desc "xml2html RELATON-INDEX-XML", "Convert Relaton Collection XML into HTML"
-      option :stylesheet, aliases: :s, desc: "Stylesheet file path for rendering HTML index"
-      option :templatedir, aliases: :t, desc: "Liquid template directory for rendering Relaton items and collection"
-      option :overwrite, aliases: :f, type: :boolean, default: false, desc: "Overwrite the existing file"
+      desc "xml2html RELATON-INDEX-XML", "Convert Relaton Collection XML into "\
+        "HTML"
+      option :stylesheet, aliases: :s, desc: "Stylesheet file path for "\
+        "rendering HTML index"
+      option :templatedir, aliases: :t, desc: "Liquid template directory for "\
+        "rendering Relaton items and collection"
+      option :overwrite, aliases: :f, type: :boolean, default: false,
+                         desc: "Overwrite the existing file"
 
       def xml2html(file, style = nil, template = nil)
         Relaton::Cli::XMLConvertor.to_html(file, style, template)
       end
 
-      desc "yaml2html RELATON-INDEX-YAML", "Concatenate Relaton Collection YAML into HTML"
-      option :stylesheet, aliases: :s, desc: "Stylesheet file path for rendering HTML index"
-      option :templatedir, aliases: :t, desc: "Liquid template directory for rendering Relaton items and collection"
-      option :overwrite, aliases: :f, type: :boolean, default: false, desc: "Overwrite the existing file"
+      desc "yaml2html RELATON-INDEX-YAML", "Concatenate Relaton Collection "\
+        "YAML into HTML"
+      option :stylesheet, aliases: :s, desc: "Stylesheet file path for "\
+        "rendering HTML index"
+      option :templatedir, aliases: :t, desc: "Liquid template directory for "\
+        "rendering Relaton items and collection"
+      option :overwrite, aliases: :f, type: :boolean, default: false,
+                         desc: "Overwrite the existing file"
 
       def yaml2html(file, style = nil, template = nil)
         Relaton::Cli::YAMLConvertor.to_html(file, style, template)
       end
 
       desc "convert XML", "Convert Relaton XML document"
-      option :format, aliases: :f, required: true, desc: "Output format (yaml, bibtex, asciibib)"
+      option :format, aliases: :f, required: true, desc: "Output format "\
+        "(yaml, bibtex, asciibib)"
       option :output, aliases: :o, desc: "Output to the specified file"
 
-      def convert(file)
-        item = Relaton::Cli.parse_xml Nokogiri::XML(File.read(file, encoding: "UTF-8"))
+      def convert(file) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        xml = Nokogiri::XML(File.read(file, encoding: "UTF-8"))
+        item = Relaton::Cli.parse_xml xml
         result = if /yaml|yml/.match?(options[:format])
                    item.to_hash.to_yaml
                  else item.send "to_#{options[:format]}"
@@ -101,34 +144,53 @@ module Relaton
         File.write output, result, encoding: "UTF-8"
       end
 
-      private
-
-      # @param code [String]
-      # @param options [Hash]
-      # @option options [String] :type
-      # @option options [String, NilClass] :format
-      # @option options [Integer, NilClass] :year
-      def fetch_document(code, options)
-        if registered_types.include?(options[:type])
-          doc = Cli.relaton.fetch(code, options[:year]&.to_s)
-          if doc
-            options[:format] == "bibtex" ? doc.to_bibtex : doc.to_xml
-          else
-            "No matching bibliographic entry found"
-          end
-        end
-      rescue RelatonBib::RequestError => e
-        e.message
-      end
+      desc "collection SUBCOMMAND", "Collection manipulations"
+      subcommand "collection", SubcommandCollection
 
-      def supported_type_message
-        ["Recognised types:", registered_types.sort.join(", ")].join(" ")
+      desc "db SUBCOMMAND", "Cache DB manipulation"
+      subcommand "db", SubcommandDb
+    end
+
+    private
+
+    # @param code [String]
+    # @param options [Hash]
+    # @option options [String] :type
+    # @option options [String, NilClass] :format
+    # @option options [Integer, NilClass] :year
+    # @return [String, nil]
+    def fetch_document(code, options) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/AbcSize
+      year = options[:year]&.to_s
+      if (processor = Relaton::Registry.instance.by_type options[:type]&.upcase)
+        doc = Relaton.db.fetch_std code, year, processor.short, options.dup
+      elsif options[:type] then return
+      else doc = Relaton.db.fetch(code, year, options.dup)
       end
+      return "No matching bibliographic entry found" unless doc
+
+      serialize doc, options[:format]
+    rescue RelatonBib::RequestError => e
+      e.message
+    end
 
-      def registered_types
-        @registered_types ||=
-          Relaton::Registry.instance.processors.each.map { |_n, pr| pr.prefix }
+    # @param doc [RelatonBib::BibliographicItem]
+    # @param format [String]
+    # @return [String]
+    def serialize(doc, format)
+      case format
+      when "yaml", "yml" then doc.to_hash.to_yaml
+      when "bibtex" then doc.to_bibtex
+      else doc.to_xml
       end
     end
+
+    def supported_type_message
+      ["Recognised types:", registered_types.sort.join(", ")].join(" ")
+    end
+
+    def registered_types
+      @registered_types ||=
+        Relaton::Registry.instance.processors.each.map { |_n, pr| pr.prefix }
+    end
   end
 end

data/lib/relaton/cli/full_text_search.rb

@@ -0,0 +1,91 @@
+# require "forwardable"
+
+module Relaton
+  class FullTextSeatch
+    # extend Forwardable
+
+    # def_delegators :@collections, :<<
+
+    # @return Regexp
+    attr_reader :regex
+
+    # @param collection [Relaton::Bibcollection]
+    def initialize(collection)
+      @collection = collection
+    end
+
+    # @param text [String]
+    # @return [Array<Hash>]
+    def search(text)
+      @regex = %{(.*?)(.{0,20})(#{text})(.{0,20})(.*)}
+      @matches = @collection.items.reduce({}) do |m, item|
+        # m + results(col, rgx)
+        res = result item
+        m[item.id] = res if res.any?
+        m
+      end
+    end
+
+    def print_results
+      @matches.each do |docid, attrs|
+        puts "  Document ID: #{docid}"
+        print_attrs attrs, 4
+      end
+    end
+
+    # @return [Boolean]
+    def any?
+      @matches.any?
+    end
+
+    private
+
+    # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+    def print_attrs(attrs, indent)
+      ind = " " * indent
+      if attrs.is_a? String then puts ind + attrs
+      elsif attrs.is_a? Hash
+        attrs.each do |key, val|
+          pref = "#{ind}#{key}:"
+          if val.is_a? String then puts pref + " " + val
+          else
+            puts pref
+            print_attrs val, indent + 2
+          end
+        end
+      elsif attrs.is_a? Array then attrs.each { |v| print_attrs v, indent + 2 }
+      end
+    end
+
+    # @param item [Relaton::Bibdata]
+    # @return [Hash]
+    def result(item)
+      if item.is_a? String
+        message $~ if item.match regex
+      elsif item.respond_to? :reduce
+        item.reduce([]) do |m, i|
+          res = result i
+          m << res if res && !res.empty?
+          m
+        end
+      else
+        item.instance_variables.reduce({}) do |m, var|
+          res = result item.instance_variable_get(var)
+          m[var.to_s.tr(":@", "")] = res if res && !res.empty?
+          m
+        end
+      end
+    end
+    # rubocop:enable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+
+    # @param match [MatchData]
+    # @return [String]
+    def message(match)
+      msg = ""
+      msg += "..." unless match[1].empty?
+      msg += "#{match[2]}\e[4m#{match[3]}\e[24m#{match[4]}"
+      msg += "..." unless match[5].empty?
+      msg
+    end
+  end
+end