eac_tools 0.2.1 → 0.4.0

data/sub/eac_cli/spec/lib/eac_cli/parser/alternative_spec.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'eac_cli/parser/alternative'
+
+RSpec.describe ::EacCli::Parser::Alternative do
+  let(:instance) { described_class.new(alternative, argv) }
+  let(:actual_parsed) { instance.parsed.to_h.symbolize_keys }
+
+  context 'without subcommands' do
+    let(:alternative) do
+      r = ::EacCli::Definition::Alternative.new
+      r.bool_opt '-b', '--opt1', 'A boolean option'
+      r.arg_opt '-a', '--opt2', 'A argument option'
+      r.bool_opt '-c', '--opt3', 'A required boolean option', required: true
+      r.pos_arg :pos1
+      r.pos_arg :pos2, optional: true, repeat: true
+      r
+    end
+
+    context 'with all values' do
+      let(:argv) { %w[--opt1 --opt2 OPT2 --opt3 POS1 POS2_1 POS2_2] }
+      let(:parsed_expected) do
+        {
+          opt1: true, opt2: 'OPT2', opt3: true, pos1: 'POS1', pos2: %w[POS2_1 POS2_2]
+        }
+      end
+
+      it { expect(instance.error).to be_blank }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'with only required values' do
+      let(:argv) { %w[--opt3 POS1] }
+      let(:parsed_expected) { { opt1: false, opt2: nil, opt3: true, pos1: 'POS1', pos2: [] } }
+
+      it { expect(instance.error).to be_blank }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'with double dash' do
+      let(:argv) { %w[--opt3 POS1 -- --opt1 --] }
+      let(:parsed_expected) do
+        { opt1: false, opt2: nil, opt3: true, pos1: 'POS1', pos2: %w[--opt1 --] }
+      end
+
+      it { expect(instance.error).to be_blank }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'without required positional' do
+      let(:argv) { %w[--opt1 --opt3] }
+      let(:parsed_expected) { { opt1: true, opt2: nil, opt3: true, pos1: nil, pos2: [] } }
+
+      it { expect(instance.error).to be_present }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'without required option' do
+      let(:argv) { %w[--opt1 POS1] }
+      let(:parsed_expected) { { opt1: true, opt2: nil, opt3: false, pos1: 'POS1', pos2: [] } }
+
+      it { expect(instance.error).to be_present }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'without any required option or positional' do
+      let(:argv) { %w[] }
+      let(:parsed_expected) { { opt1: false, opt2: nil, opt3: false, pos1: nil, pos2: [] } }
+
+      it { expect(instance.error).to be_present }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'with excedent positional' do
+      let(:alternative) do
+        r = ::EacCli::Definition::Alternative.new
+        r.pos_arg :pos1
+        r
+      end
+
+      let(:argv) { %w[POS1 POS2] }
+      let(:parsed_expected) { { pos1: 'POS1' } }
+
+      it { expect(instance.error).to be_present }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+  end
+
+  context 'with subcommands' do
+    let(:alternative) do
+      r = ::EacCli::Definition::Alternative.new
+      r.bool_opt '-b', '--opt1', 'A boolean option'
+      r.arg_opt '-a', '--opt2', 'A argument option'
+      r.subcommands
+      r
+    end
+
+    context 'with all values' do
+      let(:argv) { %w[--opt1 --opt2 OPT2 CMD CMD_ARG_1 --CMD_ARG_2] }
+      let(:parsed_expected) do
+        {
+          opt1: true, opt2: 'OPT2',
+          ::EacCli::Definition::Alternative::SUBCOMMAND_NAME_ARG => 'CMD',
+          ::EacCli::Definition::Alternative::SUBCOMMAND_ARGS_ARG => %w[CMD_ARG_1 --CMD_ARG_2]
+        }
+      end
+
+      it { expect(instance.error).to be_blank }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'with only required values' do
+      let(:argv) { %w[CMD] }
+      let(:parsed_expected) do
+        {
+          opt1: false, opt2: nil,
+          ::EacCli::Definition::Alternative::SUBCOMMAND_NAME_ARG => 'CMD',
+          ::EacCli::Definition::Alternative::SUBCOMMAND_ARGS_ARG => []
+        }
+      end
+
+      it { expect(instance.error).to be_blank }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+
+    context 'without required values' do
+      let(:argv) { %w[--opt1] }
+      let(:parsed_expected) do
+        {
+          opt1: true, opt2: nil,
+          ::EacCli::Definition::Alternative::SUBCOMMAND_NAME_ARG => nil,
+          ::EacCli::Definition::Alternative::SUBCOMMAND_ARGS_ARG => []
+        }
+      end
+
+      it { expect(instance.error).to be_present }
+      it { expect(actual_parsed).to eq(parsed_expected) }
+    end
+  end
+end

data/sub/eac_cli/spec/lib/eac_cli/runner_spec.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner'
+
+RSpec.describe ::EacCli::Runner do
+  let(:runner_class) do
+    the_module = described_class
+    ::Class.new do
+      include the_module
+
+      runner_definition do
+        arg_opt '-o', '--opt1', 'A arg option.'
+        bool_opt '-p', '--opt2', 'A boolean option'
+        arg_opt '-q', '--opt4', 'A repeatable argument option.', repeat: true
+        bool_opt '-r', '--opt5', 'A repeatable boolean option', repeat: true
+        arg_opt '-s', '--opt6', 'A argument option with default value', default: 'DEFAULT'
+        pos_arg :pos1
+        pos_arg :pos2, repeat: true, optional: true
+        alt do
+          bool_opt '-a', '--opt3', 'A boolean option in a alternative.', required: true
+        end
+      end
+
+      def run; end
+    end
+  end
+
+  let(:instance) { runner_class.create(argv) }
+  let(:parsed_actual) { instance.parsed.to_h.symbolize_keys }
+
+  context 'when all args are supplied' do
+    let(:argv) { %w[--opt1 aaa --opt2 bbb ccc ddd --opt6 6] }
+    let(:parsed_expected) do
+      { opt1: 'aaa', opt2: true, opt3: false, opt4: [], opt5: 0, opt6: '6', pos1: 'bbb',
+        pos2: %w[ccc ddd] }
+    end
+
+    it { expect(parsed_actual).to eq(parsed_expected) }
+    it { expect(instance.parsed.opt1).to eq('aaa') }
+    it { expect(instance.parsed.opt2?).to eq(true) }
+    it { expect(instance.parsed.pos1).to eq('bbb') }
+    it { expect(instance.parsed.pos2).to eq(%w[ccc ddd]) }
+  end
+
+  context 'with long option and argument in same position' do
+    let(:argv) { %w[--opt1=aaa pos1] }
+
+    it { expect(instance.parsed.opt1).to eq('aaa') }
+  end
+
+  context 'with valid grouped short options' do
+    let(:argv) { %w[-po aaa pos1] }
+
+    it { expect(instance.parsed.opt1).to eq('aaa') }
+    it { expect(instance.parsed.opt2?).to eq(true) }
+  end
+
+  context 'with invalid grouped short options' do
+    let(:argv) { %w[-op aaa pos1] }
+
+    it do
+      expect { instance.parsed }.to raise_error(::EacCli::Parser::Error)
+    end
+  end
+
+  context 'when only required args are supplied' do
+    let(:argv) { %w[bbb] }
+    let(:parsed_expected) do
+      { opt1: nil, opt2: false, opt3: false, opt4: [], opt5: 0, opt6: 'DEFAULT', pos1: 'bbb',
+        pos2: [] }
+    end
+
+    it { expect(parsed_actual).to eq(parsed_expected) }
+    it { expect(instance.parsed.opt1).to be_nil }
+    it { expect(instance.parsed.opt2?).to eq(false) }
+    it { expect(instance.parsed.pos1).to eq('bbb') }
+    it { expect(instance.parsed.pos2).to eq([]) }
+  end
+
+  context 'when required args are not supplied' do
+    let(:argv) { %w[] }
+
+    it do
+      expect { instance.parsed }.to raise_error(::EacCli::Parser::Error)
+    end
+  end
+
+  context 'when alternative args are supplied' do
+    let(:argv) { %w[--opt3] }
+    let(:parsed_expected) do
+      { opt1: nil, opt2: false, opt3: true, opt4: [], opt5: 0, opt6: 'DEFAULT', pos1: nil,
+        pos2: [] }
+    end
+
+    it { expect(parsed_actual).to eq(parsed_expected) }
+    it { expect(instance.parsed.opt3?).to eq(true) }
+  end
+
+  context 'when repeated options are supplied' do
+    let(:argv) { %w[--opt5 -rrr --opt4=A -q B --opt4 C AAA] }
+    let(:parsed_expected) do
+      { opt1: nil, opt2: false, opt3: false, opt4: %w[A B C], opt5: 4, opt6: 'DEFAULT', pos1: 'AAA',
+        pos2: [] }
+    end
+
+    it { expect(parsed_actual).to eq(parsed_expected) }
+  end
+
+  context 'when extra args are not supplied' do
+    let(:runner_class) do
+      the_module = described_class
+      ::Class.new do
+        include the_module
+
+        runner_definition do
+          pos_arg :pos1
+        end
+
+        def run; end
+      end
+    end
+
+    let(:argv) { %w[aaa bbb] }
+
+    it do
+      expect { instance.parsed }.to raise_error(::EacCli::Parser::Error)
+    end
+  end
+end

data/sub/eac_cli/spec/lib/eac_cli/runner_with/help_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner_with/help'
+require 'eac_ruby_utils/fs/temp'
+
+RSpec.describe ::EacCli::RunnerWith::Help do
+  let(:runner) do
+    the_module = described_class
+    Class.new do
+      include the_module
+
+      runner_definition do
+        desc 'A stub runner.'
+        pos_arg :a_argument
+      end
+
+      def run
+        puts 'Runner run'
+      end
+    end
+  end
+
+  [
+    ['--help'],
+    ['trash-pos-arg-before', '--help', 'trash-pos-arg-after']
+  ].each do |runner_argv|
+    context "when runner ARGV is #{runner_argv}" do
+      let(:instance) { runner.create(argv: runner_argv) }
+      let(:expected_output_source) do
+        <<~OUTPUT
+          A stub runner.
+
+          Usage:
+            __PROGRAM__ [options] <a_argument>
+            __PROGRAM__ --help
+
+          Options:
+            -h --help    Show help.
+
+        OUTPUT
+      end
+      let(:expected_output) do
+        expected_output_source.gsub('__PROGRAM__', instance.program_name)
+      end
+
+      it 'show help text' do
+        expect { instance.run_run }.to output(expected_output).to_stdout_from_any_process
+      end
+    end
+  end
+end

data/sub/eac_cli/spec/lib/eac_cli/runner_with/subcommands_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner'
+require 'eac_cli/runner_with/help'
+require 'eac_cli/runner_with/subcommands'
+
+RSpec.describe ::EacCli::RunnerWith::Subcommands do
+  let(:parent_runner) do
+    the_module = described_class
+    the_child = child_runner
+    Class.new do
+      include the_module
+      const_set('ChildCmd', the_child)
+
+      runner_definition do
+        desc 'A stub root runner.'
+        arg_opt '-r', '--root-var', 'A root variable.'
+        subcommands
+      end
+
+      delegate :root_var, to: :parsed
+    end
+  end
+
+  let(:child_runner) do
+    ::Class.new do
+      include ::EacCli::Runner
+
+      runner_definition do
+        bool_opt '-c', '--child-opt', 'A boolean option.'
+        pos_arg :child_var
+      end
+
+      def run; end
+    end
+  end
+
+  let(:instance) { parent_runner.create(argv: parent_argv) }
+
+  context 'when subcommand is supplied' do
+    let(:parent_argv) { %w[--root-var 123 child-cmd --child-opt 456] }
+
+    it { expect(instance.parsed.root_var).to eq('123') }
+    it { expect(instance.parsed.subcommand).to eq('child-cmd') }
+    it { expect(instance.parsed.subcommand_args).to eq(%w[--child-opt 456]) }
+    it { expect(instance.subcommand_runner.parsed.child_opt).to eq(true) }
+    it { expect(instance.subcommand_runner.parsed.child_var).to eq('456') }
+  end
+
+  context 'when subcommand is not supplied' do
+    let(:instance) { parent_runner.create(%w[456]) }
+
+    it do
+      expect { instance.run }.to raise_error(::EacCli::Parser::Error)
+    end
+  end
+
+  context 'with help' do
+    let(:instance) { parent_runner.create(%w[--help]) }
+    let(:expected_output_source) do
+      <<~OUTPUT
+        A stub root runner.
+
+        Usage:
+          __PROGRAM__ [options] __SUBCOMMANDS__ [<subcommand_args>...]
+          __PROGRAM__ --help
+
+        Options:
+          -r --root-var=<value>    A root variable.
+          -h --help    Show help.
+
+        Subcommands:
+          child-cmd
+      OUTPUT
+    end
+    let(:expected_output) do
+      expected_output_source.gsub('__PROGRAM__', instance.program_name)
+    end
+
+    before do
+      parent_runner.include(::EacCli::RunnerWith::Help)
+    end
+
+    it 'show help text' do
+      expect { instance.run_run }.to output(expected_output).to_stdout_from_any_process
+    end
+  end
+end

data/sub/eac_cli/spec/lib/eac_cli/speaker_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'eac_cli/speaker'
+
+RSpec.describe ::EacCli::Speaker do
+  let(:instance) { described_class.new }
+
+  describe '#input' do
+    it 'recover value from hash list' do
+      allow(instance).to receive(:request_string).and_return('opt1')
+      list = { opt1: 'value1', opt2: 'value2' }
+      expect(instance.input('Question', list: list)).to eq('value1')
+    end
+
+    it 'recover value from array list' do
+      allow(instance).to receive(:request_string).and_return('OPT1')
+      list = %w[opt1 opt2]
+      expect(instance.input('Question', list: list)).to eq('opt1')
+    end
+
+    {
+      'yes' => true, 'y' => true, 'Y' => true, 'NO' => false, 'no' => false, 'n' => false
+    }.each do |input, expected|
+      context "when bool: true and input is \"#{input}\"" do
+        it "return #{expected}" do
+          allow(instance).to receive(:request_string).and_return(input)
+          expect(instance.input('Question', bool: true)).to eq(expected)
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/spec/rubocop_spec.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+::EacRubyUtils::Rspec.default_setup.describe_rubocop

data/sub/eac_cli/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/rspec/default_setup'
+::EacRubyUtils::Rspec.default_setup_create(::File.expand_path('..', __dir__))

data/sub/eac_fs/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec

data/sub/eac_fs/eac_fs.gemspec

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+
+require 'eac_fs/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'eac_fs'
+  s.version     = EacFs::VERSION
+  s.authors     = ['Put here the authors']
+  s.summary     = 'Put here de description.'
+
+  s.files = Dir['{lib}/**/*']
+
+  s.add_dependency 'content-type'
+  s.add_dependency 'eac_ruby_utils', '~> 0.70'
+  s.add_dependency 'ruby-filemagic'
+
+  s.add_development_dependency 'eac_ruby_gem_support', '~> 0.5.1'
+end

data/sub/eac_fs/lib/eac_fs/cached_download.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'eac_fs/patches'
+require 'eac_ruby_utils/fs/temp'
+require 'open-uri'
+
+module EacFs
+  class CachedDownload
+    attr_reader :url, :fs_cache
+
+    def initialize(url, parent_fs_cache = nil)
+      @url = url
+      @fs_cache = (parent_fs_cache || fs_cache).child(url.to_s.parameterize)
+    end
+
+    def assert
+      download unless fs_cache.stored?
+    end
+
+    def download
+      ::EacRubyUtils::Fs::Temp.on_file do |temp|
+        download_to(temp)
+        fs_cache.content_path.to_pathname.dirname.mkpath
+        ::FileUtils.mv(temp.to_path, fs_cache.content_path)
+      end
+    end
+
+    def path
+      fs_cache.content_path.to_pathname
+    end
+
+    private
+
+    def download_to(local_file)
+      ::URI.parse(url).open do |remote|
+        local_file.open('wb') { |handle| handle.write(remote.read) }
+      end
+    end
+  end
+end

data/sub/eac_fs/lib/eac_fs/contexts.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/context'
+
+module EacFs
+  class Contexts
+    TYPES = %i[cache config data].freeze
+
+    class << self
+      TYPES.each do |type|
+        class_eval <<~CODE, __FILE__, __LINE__ + 1
+          # @return [EacRubyUtils::Context<EacFs::StorageTree>]
+          def #{type}
+            @#{type} ||= ::EacRubyUtils::Context.new
+          end
+        CODE
+      end
+    end
+  end
+end

data/sub/eac_fs/lib/eac_fs/file_info.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'content-type'
+require 'filemagic'
+
+module EacFs
+  class FileInfo
+    UNKNOWN_CONTENT_TYPE_STRING = 'application/octet-stream'
+    UNKNOWN_CONTENT_TYPE = ::ContentType.parse(UNKNOWN_CONTENT_TYPE_STRING)
+
+    enable_simple_cache
+    attr_reader :magic_string
+
+    def initialize(path)
+      @magic_string = ::FileMagic.new(FileMagic::MAGIC_MIME).file(path.to_pathname.to_path)
+    end
+
+    delegate :charset, :mime_type, :subtype, :type, to: :content_type
+
+    private
+
+    def content_type_uncached
+      ::ContentType.parse(magic_string)
+    rescue ::Parslet::ParseFailed
+      UNKNOWN_CONTENT_TYPE
+    end
+  end
+end

data/sub/eac_fs/lib/eac_fs/logs/file.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacFs
+  class Logs
+    class File
+      enable_simple_cache
+      common_constructor :label
+
+      TRUNCATE_DEFAULT_LENGTH = 1000
+      TRUNCATE_APPEND_TEXT = '(...) '
+
+      delegate :remove, to: :file
+
+      def clean
+        file.truncate(0) if file.exist?
+      end
+
+      def file_size
+        file.file? ? file.size : 0
+      end
+
+      def pretty_file_size
+        ::Filesize.from("#{file_size} B").pretty
+      end
+
+      # @param length [Integer]
+      # @return [String]
+      def truncate(length = TRUNCATE_DEFAULT_LENGTH)
+        content = file.file? ? file.read.strip : ''
+        return content if content.length <= TRUNCATE_DEFAULT_LENGTH
+
+        TRUNCATE_APPEND_TEXT + content[content.length - length + TRUNCATE_APPEND_TEXT.length,
+                                       length - TRUNCATE_APPEND_TEXT.length]
+      end
+
+      # @param length [Integer]
+      # @return [String]
+      def truncate_with_label(length = TRUNCATE_DEFAULT_LENGTH)
+        header = [label, file, pretty_file_size].join(' / ')
+        return ">>> #{header} (Not found) <<<" unless file.file?
+
+        content = truncate(length)
+        content.blank? ? ">>> #{header} (Blank) <<<" : ">>> #{header}\n#{content}\n<<< #{header}\n"
+      end
+
+      protected
+
+      # @return [EacRubyUtils::Fs::Temp::File
+      def file_uncached
+        ::EacRubyUtils::Fs::Temp.file
+      end
+    end
+  end
+end

data/sub/eac_fs/lib/eac_fs/logs.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/fs/temp'
+require 'filesize'
+
+module EacFs
+  class Logs
+    require_sub __FILE__
+
+    # @param label [Symbol]
+    # @return [EacRubyUtils::Fs::Temp::File]
+    def [](label)
+      log_set.fetch(sanitize_label(label)).file
+    end
+
+    # @param label [Symbol]
+    # @return [EacFs::Logs]
+    def add(label)
+      file = ::EacFs::Logs::File.new(sanitize_label(label))
+      log_set[file.label] = file
+
+      self
+    end
+
+    # @return [EacFs::Logs]
+    def clean_all
+      log_set.values.each(&:clean)
+    end
+
+    # @return [EacFs::Logs]
+    def remove_all
+      log_set.each_key { |label| remove(label) }
+
+      self
+    end
+
+    # @param label [Symbol]
+    def remove(label)
+      log_set.fetch(sanitize_label(label)).remove
+      log_set.delete(sanitize_label(label))
+    end
+
+    # @param length [Integer]
+    # @return [String]
+    def truncate_all(length = ::EacFs::Logs::File::TRUNCATE_DEFAULT_LENGTH)
+      "Files: #{log_set.length}\n" +
+        log_set.values.map { |file| file.truncate_with_label(length) }.join
+    end
+
+    private
+
+    # @param label [Object]
+    # @return [Symbol]
+    def sanitize_label(label)
+      label.to_sym
+    end
+
+    # @return [Hash<Symbol, EacFs::Logs::File>]
+    def log_set
+      @log_set ||= {}
+    end
+  end
+end