libis-tools 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6ac60f332c876e86ca3f751e4a99b68a10b60f03
-  data.tar.gz: cc488738791b1535b7c79fdc9dbf7b7e75847dca
+  metadata.gz: 3471bd7089b2059df27dd50e932a5d069fd81caa
+  data.tar.gz: d361302b0cf5b1ebbbe489f6fb88b04a740955bb
 SHA512:
-  metadata.gz: 3c74151553d0042175b87149cc9f19d15efbb23191e32dce0c37d3f40ef17eb9872005b9757aafec0cf159b905fbdd4bbc9609248d61a0874d5a3fa3f1a47a66
-  data.tar.gz: ee214d77eae0e39be7a08b6bfdbb1daf4568814aa5be02bc35ee93095b090fd0abd04ee5bee4f40e96e9413dc3fa30769c08feb02a6db9b0ed8da7dac0ffe05c
+  metadata.gz: fdb901ba14397b93eec5157bb28b6ee0c39b0ecbb0e094b1b5a87a7e183338fb89ec2b0460b049035381179cc45f9c4661b1185c7f9a61b38085308546f69dea
+  data.tar.gz: fa413bbcdc1349838b9cc8f6156b4fd52a7466ed382b3f98b47abd4f87fa0925eb8b010c951fea4cbec59b4e857435254f9624d9c50549f760d85b3c0bc6af2f

data/bin/libis_tool

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'libis/tools'
+
+Libis::Tools::CommandLine.start(ARGV)

data/lib/libis/tools.rb

@@ -3,6 +3,8 @@ require_relative 'tools/version'
 module Libis
   module Tools
 
+    autoload :CommandLine, 'libis/tools/command_line'
+
     autoload :Checksum, 'libis/tools/checksum'
     autoload :Command, 'libis/tools/command'
     autoload :Config, 'libis/tools/config'

data/lib/libis/tools/cli/cli_helper.rb

@@ -0,0 +1,189 @@
+require 'tty-prompt'
+require 'tty-config'
+require 'pastel'
+
+module Libis
+  module Tools
+    module Cli
+      module Helper
+
+        module ClassMethods
+
+          def exit_on_failure?
+            true
+          end
+
+        end
+
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        attr_reader :prompt, :config, :pastel, :config_file_prefix
+
+        def initialize(*args)
+          @prompt = TTY::Prompt.new
+          @config = TTY::Config.new
+          @pastel = Pastel.new
+          @config.append_path Dir.home
+          @config_file_prefix = '.tools.'
+          prompt.warn "Default config file: #{config.filename}"
+          super
+        end
+
+        protected
+
+        private
+
+        def index_of(list, value)
+          i = list.index(value)
+          i += 1 if i
+          i || 1
+        end
+
+        def config_write(name = nil)
+          set_config_name(name || new_config)
+          unless get_config_name
+            prompt.error 'Could not write the configuration file: configuration not set'
+            return
+          end
+          config.write force: true
+        end
+
+        def config_read(name = nil)
+          config.filename = name ?
+                                "#{config_file_prefix}#{name}" :
+                                select_config_file(with_new: false)
+          unless get_config_name
+            prompt.error 'Could not read the configuration file: configuration not set'
+            return
+          end
+          config.read
+        rescue TTY::Config::ReadError
+          prompt.error('Could not read the configuration file.')
+          exit
+        end
+
+        def toggle_config(field)
+          config.set(field, value: !config.fetch(field))
+        end
+
+        def get_config_name
+          return $1 if get_config_file.match(config_file_regex)
+          nil
+        end
+
+        def get_config_file
+          config.filename
+        end
+
+        def config_file_regex(with_ext: false)
+          /^#{Regexp.quote(config_file_prefix)}(.+)#{Regexp.quote(config.extname) if with_ext}$/
+        end
+
+        def set_config_name(name)
+          config.filename = "#{config_file_prefix}#{name}" if name && !name.empty?
+        end
+
+        def set_config_file(name)
+          config.filename = name if name && !name.empty?
+        end
+
+        def select_config_file(*args)
+          "#{config_file_prefix}#{select_config_name *args}"
+        end
+
+        def select_config_name(with_new: true, force_select: false)
+          current_cfg = get_config_name
+          return current_cfg if !force_select && current_cfg
+
+          cfgs = []
+          cfgs << {
+              name: '-- new configuration --',
+              value: -> do
+                new_config
+              end
+          } if with_new
+          cfgs += Dir.glob(File.join(Dir.home, "#{config_file_prefix}*")).reduce([]) do |a, x|
+            a.push($1) if File.basename(x).match(config_file_regex(with_ext: true))
+            a
+          end
+
+          return nil if cfgs.empty?
+
+          prompt.select '[ Select config menu ]', cfgs, default: index_of(cfgs, current_cfg), filter: true
+        end
+
+        def new_config
+          while true
+            name = prompt.ask('Enter a name for the configuration:', modify: :trim)
+            return name unless File.exist?(File.join(Dir.home, "#{config_file_prefix}#{name}#{config.extname}")) &&
+                !prompt.yes?("Configuration '#{name}' already exists. Overwrite?")
+          end
+        end
+
+        def ask(question, field, bool: false, enum: nil, default: nil, mask: false, if_empty: false)
+          cmd, args, opts = :ask, [question], {}
+          default ||= config.fetch(field)
+          if enum
+            cmd = :select
+            args << enum
+            # Change default to its index in the enum
+            default = index_of(enum, default)
+            # Force the question if the supplied value is not valid
+            config.delete field unless !if_empty || enum.include?(config.fetch field)
+          end
+          cmd = :mask if mask
+          opts[:default] = config.fetch(field)
+          opts[:default] = default if default
+          cmd = (opts[:default] ? :yes? : :no?) if bool
+          config.set(field, value: prompt.send(cmd, *args, opts)) unless if_empty && config.fetch(field)
+        end
+
+        def tree_select(path, question: nil, file: false, page_size: 22, filter: true, cycle: false, create: false,
+                        default_choices: nil)
+          path = Pathname.new(path) unless path.is_a? Pathname
+
+          return path unless path.exist?
+          path = path.realpath
+
+          dirs = path.children.select(&:directory?).sort
+          files = file ? path.children.select(&:file?).sort : []
+
+          choices = []
+          choices << {name: "Folder: #{path}", value: path, disabled: file ? '' : false}
+          choices += default_choices if default_choices
+          choices << {name: '-- new directory --', value: -> do
+            new_name = prompt.ask('new directory name:', modify: :trim, required: true)
+            new_path = path + new_name
+            FileUtils.mkdir(new_path.to_path)
+            new_path
+          end
+          } if create
+
+          choices << {name: "-- new file --", value: -> do
+            new_name = prompt.ask('new file name:', modify: :trim, required: true)
+            path + new_name
+          end
+          } if file && create
+
+          choices << {name: '[..]', value: path.parent}
+
+          dirs.each {|d| choices << {name: "[#{d.basename}]", value: d}}
+          files.each {|f| choices << {name: f.basename.to_path, value: f}}
+
+          question ||= "Select #{'file or ' if files}directory"
+          selection = prompt.select question, choices,
+                                    per_page: page_size, filter: filter, cycle: cycle, default: file ? 2 : 1
+
+          return selection unless selection.is_a? Pathname
+          return selection.to_path if selection == path || selection.file?
+
+          tree_select selection, question: question, file: file, page_size: page_size, filter: filter,
+                      cycle: cycle, create: create, default_choices: default_choices
+        end
+
+      end
+    end
+  end
+end

data/lib/libis/tools/cli/reorg.rb

@@ -0,0 +1,407 @@
+require 'libis/tools/spreadsheet'
+require 'awesome_print'
+
+module Libis
+  module Tools
+    module Cli
+      module Reorg
+
+        # noinspection RubyExpressionInStringInspection
+        DEFAULT_CONFIG = {
+            base: '.',
+            filter: '^(.*)$',
+            expression: 'target/#{file_name}',
+            action: 'move',
+            overwrite: false,
+            interactive: false,
+            report: nil,
+            dummy: false,
+            config: nil,
+            unattended: false
+        }
+
+        # noinspection RubyStringKeysInHashInspection
+        VALID_ACTIONS = {
+            'move' => 'moved',
+            'copy' => 'copied',
+            'link' => 'linked'
+        }
+
+        STRING_CONFIG = {
+            base: "Source Directory to organize",
+            filter: "File matching filter",
+            expression: "New file path expression",
+            action: "Action to perform",
+            overwrite: "Overwite target files if newer",
+            interactive: "Ask for action on changed files",
+            report: "Report file",
+            dummy: "Perform phantom actions (not affecting files)"
+        }
+
+        REQ_HEADERS = {term: 'Term'}
+        OPT_HEADERS = {pid: 'Pid', filename: 'File'}
+
+        def self.included(klass)
+          klass.class_exec do
+            desc 'reorg [options]', 'Reorganize files'
+            long_desc <<-DESC
+      
+            'reorg [options]' will reorganize files based on the name of the files.
+
+            The base directory will be scanned for files that match the FILTER regular expression. For each matching
+            file, an action will be performed. The outcome of the action is determined by the expression that is given.
+
+            The expression will be evaluated as a Ruby string expression and supports string interpolation in the form
+            '\#{<thing>}', where <thing> can be any of:
+
+            . $x : refers to the x-th group in the FILTER. Groups are numbered by the order of the opening '('
+
+            . file_name : the original file name
+
+            The action that will be performed on the action depens on the configured ACTION. The valid ACTIONs are; 
+            'move', copy' and 'link'. Please note that in the latter case only the files will be soft-linked and any 
+            directory in the target path will be created. The tool will therefore never create soft-links to directories. 
+            The soft-links are created with an absolute reference path. This allows you to later move and rename the 
+            soft-links later as you seem fit without affecting the source files. You could for instance run this tool on 
+            the soft-links with the 'move' action to do so.
+
+            By default, if the target file already exists, the file ACTION will not be performed. The '--overwrite'
+            option will cause the tool to compare the file dates and checksums of source and target files in that case.
+            Only if the checksums are different and the source file has a more recent modification date, the target file 
+            will be overwritten. If you want to be asked for overwrite confirmation for each such file, you can add the 
+            '--interactive' option.
+
+            The tool can generate a report on all the file actions that have been performed. To do so, specify a file
+            name for the '--report' option. The format of the report will be determined by the file extension you supply:
+
+            - *.csv : comma-separated file
+
+            - *.tsv : tab-separated file
+
+            - *.yml : YAML file
+
+            - *.xml : XML file
+
+            By adding the --dummy option, you can test your settings without performing the real actions on the file.
+            The tool will still report on its progress as if it would perform the actions.
+
+            All the options can be saved into a configuration file to be reused later. You can specify which 
+            configuration file you want to use with the '--config' option. If you specify a configuration file, the tool
+            will first load the options from the configuration file and then process the command-line options. The 
+            command-line options therefore have priority over the options in the configuration file.
+
+            By default the tool allows you to review the activated options and gives you the opportunity to modify them
+            before continuing of bailing out. If you are confident the settings are fine, you can skip this with the
+            '--unatttended' option. Handle with care!
+
+            DESC
+
+            method_option :base, aliases: '-b', desc: 'Directory that needs to be reorganized',
+                          default: DEFAULT_CONFIG[:base]
+            method_option :filter, aliases: '-f', desc: 'Regex for file name matching',
+                          default: DEFAULT_CONFIG[:filter]
+            method_option :expression, aliases: '-e', desc: 'Ruby string expression for the new file path',
+                          default: DEFAULT_CONFIG[:expression]
+
+            method_option :action, aliases: '-a', desc: 'Operation to perform on files found',
+                          enum: VALID_ACTIONS.keys, default: DEFAULT_CONFIG[:action]
+            method_option :overwrite, aliases: '-o', desc: 'Overwrite target if changed',
+                          type: :boolean, default: DEFAULT_CONFIG[:overwrite]
+            method_option :interactive, aliases: '-i', desc: 'Ask for action when changed files are found',
+                          type: :boolean, default: DEFAULT_CONFIG[:interactive]
+
+            method_option :report, aliases: '-r', banner: 'FILE', desc: 'Generate report in FILE',
+                          default: DEFAULT_CONFIG[:report]
+
+            method_option :dummy, desc: 'Do not perform file actions, only report them',
+                          type: :boolean, default: DEFAULT_CONFIG[:dummy]
+
+            method_option :config, aliases: '-c', desc: 'Configuration name to use',
+                          type: :string, default: DEFAULT_CONFIG[:config]
+
+            method_option :unattended, aliases: '-u', desc: 'Run without asking for input',
+                          type: :boolean, default: DEFAULT_CONFIG[:unattended]
+
+          end
+
+        end
+
+        def reorg
+          @config_file_prefix = '.reorg.'
+
+          # return config_write
+
+          DEFAULT_CONFIG.each {|key, value| config.set(key, value: value) if value}
+          config_read(options[:config]) if options[:config]
+          DEFAULT_CONFIG.each {|key, _| config.set(key, value: options[:key]) if options.has_key?(key)}
+          run_menu
+        end
+
+        protected
+
+        def run_menu
+
+          begin
+            choices = []
+
+            choices << {name: "Configuration editor",
+                        value: -> {config_menu; 1}
+            }
+
+            choices << {name: "Run", value: -> {do_reorg; nil}}
+            choices << {name: "Exit", value: nil}
+
+            selection = prompt.select "[ LIBIS Tool - ReOrg ]",
+                                      choices, cycle: true, default: 1
+
+          end until selection.nil?
+
+        end
+
+        def print_field(field)
+          value = config.fetch(field)
+          value = 'Yes' if value.is_a?(TrueClass)
+          value = 'No' if value.is_a?(FalseClass)
+          "#{STRING_CONFIG[field]} : #{pastel.green(value)}"
+        end
+
+        def config_menu
+
+          selection = 1
+
+          begin
+            choices = []
+            choices << {name: print_field(:base),
+                        value: -> do
+                          config.set :base,
+                                     value: tree_select(config.fetch(:base) || '.', question: 'Select source directory:')
+                          1
+                        end
+            }
+            choices << {name: print_field(:filter),
+                        value: -> {ask 'File filter regex:', :filter; 2}
+            }
+            choices << {name: print_field(:expression),
+                        value: -> {ask 'New path expression:', :expression; 3}
+            }
+            choices << {name: print_field(:action),
+                        value: -> {ask 'Action:', :action, enum: VALID_ACTIONS.keys; 4}
+            }
+            choices << {name: print_field(:overwrite),
+                        value: -> {toggle_config(:overwrite); prompt.say print_field(:overwrite); 5}
+            }
+            choices << {name: print_field(:interactive),
+                        value: -> {toggle_config(:interactive); prompt.say print_field(:interactive); 6}
+            }
+            choices << {name: print_field(:report),
+                        value: -> do
+                          report = config.fetch(:report)
+                          default = '.'
+                          default = File.dirname(report) if report && File.file?(report)
+                          report = tree_select(default, question: 'Select source directory',
+                                               file: true, create: true,
+                                               default_choices: [{name: "-- no report --", value: nil}])
+                          if report
+                            config.set(:report, value: report)
+                          else
+                            config.delete(:report)
+                          end
+                          7
+                        end
+            }
+            choices << {name: print_field(:dummy),
+                        value: -> {toggle_config(:dummy); prompt.say print_field(:dummy); 8}
+            }
+            choices << {name: "-- save configuration '#{get_config_name}' --",
+                        value: -> {config_write get_config_name; 9}
+            } if get_config_name
+            choices << {name: "-- save to new configuration --",
+                        value: -> {config_write new_config; 10}
+            }
+            choices << {name: "-- read configuration --",
+                        value: -> {config_read; 11}
+            }
+            choices << {name: "-- return to main menu --", value: nil}
+
+            selection = prompt.select "[ Configuration menu ]",
+                                      choices, per_page: 20, cycle: true, default: selection
+
+          end until selection.nil?
+
+        end
+
+        def do_reorg
+          prompt.ok 'This can take a while. Please sit back and relax, grab a cup of coffee, have a quick nap or read a good book ...'
+
+          # keeps track of folders created
+          require 'set'
+          target_dir_list = Set.new
+
+          open_report
+
+          require 'fileutils'
+          count = {move: 0, duplicate: 0, update: 0, reject: 0, skipped_dir: 0, unmatched_file: 0}
+
+          base_dir = config.fetch(:base)
+          parse_regex = Regexp.new(config.fetch(:filter))
+          path_expression = "#{config.fetch(:expression)}"
+          dummy_operation = config.fetch(:dummy)
+          interactive = config.fetch(:interactive)
+          overwrite = config.fetch(:overwrite)
+          file_operation = config.fetch(:action)
+          Dir.new(base_dir).entries.each do |file_name|
+            next if file_name =~ /^\.\.?$/
+            entry = File.join(File.absolute_path(base_dir), file_name)
+            unless File.file?(entry)
+              puts "Skipping directory #{entry}." unless @report
+              write_report(entry, '', '', 'Directory - skipped.')
+              count[:skipped_dir] += 1
+              next
+            end
+            unless file_name =~ parse_regex
+              puts "Skipping file #{file_name}. File name does not match expression." unless @report
+              write_report(entry, '', '', 'Mismatch - skipped.')
+              count[:unmatched_file] += 1
+              next
+            end
+            target = eval('"' + path_expression + '"')
+            target_file = File.basename(target)
+            target_dir = File.dirname(target)
+            target_dir = File.join(base_dir, target_dir) unless target_dir[0] == '/'
+            unless target_dir_list.include?(target_dir)
+              puts "-> Create directory '#{target_dir}'" unless @report
+              FileUtils.mkpath(target_dir) unless dummy_operation
+              target_dir_list << target_dir
+            end
+            target_path = File.join(target_dir, target_file)
+            remark = nil
+            action = false
+            if File.exist?(target_path)
+              if compare_entry(entry, target_path)
+                remark = 'Duplicate - skipped.'
+                count[:duplicate] += 1
+                $stderr.puts "Duplicate file entry: #{entry}." unless @report
+              else
+                # puts "source: #{File.mtime(entry)} #{'%11s' % Filesize.new(File.size(entry)).pretty} #{entry}"
+                # puts "target: #{File.mtime(target_path)} #{'%11s' % Filesize.new(File.size(target_path)).pretty} #{target_path}"
+                if interactive ? prompt.send((overwrite ? :yes : :no), 'Overwrite target?') : overwrite
+                  remark = 'Duplicate - updated'
+                  action = true
+                  count[:update] += 1
+                else
+                  remark = 'Duplicate - rejected.'
+                  $stderr.puts "ERROR: #{entry} exists with different content." unless @report
+                  count[:reject] += 1
+                end
+              end
+            else
+              action = true
+              count[:move] += 1
+            end
+            if action
+              puts "-> #{file_operation} '#{file_name}' to '#{target}'" unless @report
+              case file_operation
+              when 'move'
+                FileUtils.move(entry, File.join(target_dir, target_file), force: true)
+              when 'copy'
+                FileUtils.copy(entry, File.join(target_dir, target_file))
+              when 'link'
+                FileUtils.symlink(entry, File.join(target_dir, target_file), force: true)
+              else
+                # Shouldn't happen
+                raise RuntimeError, "Bad file operation: '#{file_operation}'"
+              end unless dummy_operation
+            end
+            write_report(entry, target_dir, target_file, remark)
+          end
+
+          prompt.ok "#{'%8d' % count[:skipped_dir]} dir(s) found and skipped."
+          prompt.ok "#{'%8d' % count[:unmatched_file]} file(s) found that did not match and skipped."
+          prompt.ok "#{'%8d' % count[:move]} file(s) #{VALID_ACTIONS[file_operation]}."
+          prompt.ok "#{'%8d' % count[:duplicate]} duplicate(s) found and skipped."
+          prompt.ok "#{'%8d' % count[:update]} changed file(s) found and updated."
+          prompt.ok "#{'%8d' % count[:reject]} changed file(s) found and rejected."
+
+          close_report
+
+          prompt.ok 'Done!'
+
+        end
+
+
+        def open_report
+          if (report_file = config.fetch(:report))
+            # noinspection RubyStringKeysInHashInspection
+            @report_type = {'.csv' => :csv, '.tsv' => :tsv, '.xml' => :xml, '.yml' => :yml}[File.extname(report_file)]
+            unless @report_type
+              prompt.error "Unknown file type: #{File.extname(report_file)}"
+              exit
+            end
+            @report = File.open(report_file, 'w+')
+          end
+        end
+
+        def for_tsv(string)
+          ; string =~ /\t\n/ ? "\"#{string.gsub('"', '""')}\"" : string;
+        end
+
+        def for_csv(string)
+          ; string =~ /,\n/ ? "\"#{string.gsub('"', '""')}\"" : string;
+        end
+
+        def for_xml(string, type = :attr)
+          ; string.encode(xml: type);
+        end
+
+        def for_yml(string)
+          ; string.inspect.to_yaml;
+        end
+
+        def write_report(old_name, new_folder, new_name, remark = nil)
+          return unless @report
+          case @report_type
+          when :tsv
+            @report.puts "old_name\tnew_folder\tnew_name\tremark" if @report.size == 0
+            @report.puts "#{for_tsv(old_name)}\t#{for_tsv(new_folder)}" +
+                             "\t#{for_tsv(new_name)}\t#{for_tsv(remark)}"
+          when :csv
+            @report.puts 'old_name,new_folder,new_name' if @report.size == 0
+            @report.puts "#{for_csv(old_name)},#{for_csv(new_folder)}" +
+                             ",#{for_csv(new_name)},#{for_csv(remark)}"
+          when :xml
+            @report.puts '<?xml version="1.0" encoding="UTF-8"?>' if @report.size == 0
+            @report.puts '<report>' if @report.size == 1
+            @report.puts '  <file>'
+            @report.puts "    <old_name>#{for_xml(old_name, :text)}</old_name>"
+            @report.puts "    <new_folder>#{for_xml(new_folder, :text)}</new_folder>"
+            @report.puts "    <new_name>#{for_xml(new_name, :text)}</new_name>"
+            @report.puts "    <remark>#{for_xml(remark, :text)}</remark>" if remark
+            @report.puts '  </file>'
+          when :yml
+            @report.puts '# Reorganisation report' if @report.size == 0
+            @report.puts "- old_name: #{for_yml(old_name)}" +
+                             "\n  new_folder: #{for_yml(new_folder)}" +
+                             "\n  new_name: #{for_yml(new_name)}" +
+                             (remark ? "\n  remark: #{for_yml(remark)}" : '')
+          else
+            #nothing
+          end
+        end
+
+        def close_report
+          return unless @report
+          if @report_type == :xml
+            @report.puts '</report>'
+          end
+          @report.close
+        end
+
+        def compare_entry(src, tgt)
+          hasher = Libis::Tools::Checksum.new(:SHA256)
+          hasher.digest(src) == hasher.digest(tgt)
+        end
+
+      end
+    end
+  end
+end

data/lib/libis/tools/command_line.rb

@@ -0,0 +1,23 @@
+require 'thor'
+require 'tty-prompt'
+require 'tty-config'
+
+require 'libis/tools/cli/cli_helper'
+require 'libis/tools/cli/reorg'
+
+module Libis
+  module Tools
+
+    class CommandLine < Thor
+
+      include Cli::Helper
+      include Cli::Reorg
+
+      def reorg
+        super
+      end
+
+    end
+
+  end
+end

data/lib/libis/tools/version.rb

@@ -1,5 +1,5 @@
 module Libis
   module Tools
-    VERSION = '1.0.0'
+    VERSION = '1.0.1'
   end
 end

data/libis-tools.gemspec

@@ -22,6 +22,7 @@ Gem::Specification.new do |spec|
   spec.platform      = Gem::Platform::JAVA if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
 
   spec.files         = `git ls-files -z`.split("\x0")
+  spec.bindir        = 'bin'
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
 
@@ -47,4 +48,8 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'yard', '~> 0.9.11'
   spec.add_runtime_dependency 'roo', '~> 2.5'
   spec.add_runtime_dependency 'roo-xls', '~> 1.0'
+  spec.add_runtime_dependency 'tty-prompt'
+  spec.add_runtime_dependency 'tty-config'
+  spec.add_runtime_dependency 'thor'
+
 end

data/spec/mets_file_spec.rb

@@ -34,11 +34,16 @@ describe 'METS File' do
   context 'with IE AMD' do
 
     let(:dc_record) {
-      record = Libis::Tools::Metadata::DublinCoreRecord.new
-      record.title = 'Title'
-      record.author = 'Author'
-      record.subject = 'Subject'
-      record
+      Libis::Tools::XmlDocument.parse <<-STR
+        <?xml version="1.0" encoding="UTF-8"?>
+        <record xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                xmlns:dc="http://purl.org/dc/elements/1.1/"
+                xmlns:dcterms="http://purl.org/dc/terms/">
+          <dc:title>Title</dc:title>
+          <dc:author>Author</dc:author>
+          <dc:subject>Subject</dc:subject>
+        </record>
+      STR
     }
 
     let(:marc_record) {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libis-tools
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Kris Dekeyser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-20 00:00:00.000000000 Z
+date: 2018-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -262,10 +262,53 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-config
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Some tool classes for other LIBIS gems.
 email:
 - kris.dekeyser@libis.be
-executables: []
+executables:
+- libis_tool
 extensions: []
 extra_rdoc_files: []
 files:
@@ -276,11 +319,15 @@ files:
 - Gemfile
 - README.md
 - Rakefile
+- bin/libis_tool
 - lib/libis-tools.rb
 - lib/libis/tools.rb
 - lib/libis/tools/assert.rb
 - lib/libis/tools/checksum.rb
+- lib/libis/tools/cli/cli_helper.rb
+- lib/libis/tools/cli/reorg.rb
 - lib/libis/tools/command.rb
+- lib/libis/tools/command_line.rb
 - lib/libis/tools/config.rb
 - lib/libis/tools/config_file.rb
 - lib/libis/tools/csv.rb