eac_tools 0.117.4 → 0.117.5

data/sub/eac_cli/spec/lib/eac_cli/runner_with/output_item/asciidoc_formatter_spec_files/gb_1.target.adoc

@@ -0,0 +1,22 @@
+== Finalizado
+
+* Battle Arena Toshinden
+* Kaeru no Tame ni Kane wa Naru
+* The Legend of Zelda - Link's Awakening
+
+== Gostado
+
+* Metroid II - Return of Samus
+
+=== Mario
+
+* Mario's Picross
+
+==== Super Mario Land
+
+* Super Mario Land
+* Super Mario Land 2 - 6 Golden Coins
+
+=== TMNT
+
+* Teenage Mutant Ninja Turtles III - Radical Rescue

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+RSpec.describe EacCli::RunnerWith::OutputList do
+  let(:runner) do
+    the_module = described_class
+    Class.new do
+      include the_module
+
+      def run
+        run_output
+      end
+
+      def list_columns
+        %w[id name]
+      end
+
+      def list_rows
+        [[1, 'João'], [2, 'Maria']].map { |v| Struct.new(:id, :name).new(*v) }
+      end
+    end
+  end
+
+  let(:instance) { runner.create(argv: runner_argv) }
+
+  {
+    'csv' => <<~OUTPUT,
+      id,name
+      1,João
+      2,Maria
+    OUTPUT
+    'tty' => <<~OUTPUT,
+      ┌──┬─────┐
+      │id│name │
+      │1 │João │
+      ├──┼─────┤
+      │2 │Maria│
+      └──┴─────┘
+    OUTPUT
+    'yaml' => <<~OUTPUT
+      ---
+      - id: '1'
+        name: João
+      - id: '2'
+        name: Maria
+    OUTPUT
+  }.each do |format, expected_output|
+    context "with --format=#{format}" do
+      let(:runner_argv) { ['--format', format] }
+
+      it do
+        expect { instance.run }.to output(expected_output).to_stdout_from_any_process
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+RSpec.describe EacCli::RunnerWith::Output do
+  let(:runner) do
+    the_module = described_class
+    Class.new do
+      include the_module
+
+      attr_accessor :temp_dir
+
+      runner_definition do
+        desc 'A stub root runner.'
+        pos_arg :input_text
+      end
+
+      def run
+        run_output
+      end
+
+      def output_content
+        parsed.input_text
+      end
+
+      def default_file_to_output
+        temp_dir.join('default_file')
+      end
+    end
+  end
+
+  let(:stub_text) { 'STUB_TEXT' }
+  let(:instance) do
+    r = runner.create(argv: runner_argv)
+    r.temp_dir = temp_dir
+    r
+  end
+  let(:temp_dir) { EacRubyUtils::Fs::Temp.directory }
+
+  after { temp_dir.remove }
+
+  context 'without --output option' do
+    let(:runner_argv) { [stub_text] }
+
+    it do
+      expect { instance.run }.to output(stub_text).to_stdout_from_any_process
+    end
+  end
+
+  context 'without --output option as to stdout' do
+    let(:runner_argv) { ['--output', EacCli::RunnerWith::Output::STDOUT_OPTION, stub_text] }
+
+    it do
+      expect { instance.run }.to output(stub_text).to_stdout_from_any_process
+    end
+  end
+
+  context 'without --output option as to default file' do
+    let(:output_file) { temp_dir.join('default_file') }
+    let(:runner_argv) do
+      ['--output', EacCli::RunnerWith::Output::DEFAULT_FILE_OPTION,
+       stub_text]
+    end
+
+    before { instance.run }
+
+    it { expect(output_file).to exist }
+    it { expect(output_file.read).to eq(stub_text) }
+  end
+
+  context 'with --output option' do
+    let(:output_file) { temp_dir.join('a output file') }
+    let(:runner_argv) { ['--output', output_file.to_path, stub_text] }
+
+    before { instance.run }
+
+    it { expect(output_file).to exist }
+    it { expect(output_file.read).to eq(stub_text) }
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+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
+      for_context :method_in_parent_runner
+
+      def method_in_parent_runner; end
+    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
+        runner_context.call(:method_in_parent_runner)
+        method_in_parent_runner
+      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 be(true) }
+    it { expect(instance.subcommand_runner.parsed.child_var).to eq('456') }
+
+    it do
+      expect { instance.run_run }.not_to raise_error
+    end
+  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,34 @@
+# frozen_string_literal: true
+
+RSpec.describe EacCli::Speaker do
+  let(:instance) { described_class.new }
+
+  before do
+    allow(instance).to receive(:warn) { |message| raise(message.to_s) }
+  end
+
+  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/spec_helper.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'eac_cli'
+require 'eac_ruby_gem_support'
+EacRubyUtils::Rspec.default_setup_create(File.expand_path('..', __dir__))

data/sub/eac_ruby_utils/.gitignore

@@ -0,0 +1,4 @@
+Gemfile.local
+Gemfile.lock
+doc/
+.yardoc/

data/sub/eac_ruby_utils/.gitrepo

@@ -0,0 +1,7 @@
+[subrepo]
+  cmdver = 0.4.9
+  commit = b3bb86c0beb53d887b5380003aae94d75c7649b9
+  method = merge
+  parent = 7c9f827ae57e6b651b2d6ce15bb5c75ee45d7232
+  branch = master
+  remote = https://github.com/esquilo-azul/eac_ruby_utils.git

data/sub/eac_ruby_utils/.yardopts

@@ -0,0 +1 @@
+--no-private --protected lib/**/*.rb

data/sub/eac_ruby_utils/MIT-LICENCE

@@ -0,0 +1,16 @@
+Copyright 2018 Eduardo Henrique Bogoni <eduardobogoni@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES
+OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/sub/eac_ruby_utils/README.rdoc

@@ -0,0 +1,3 @@
+= E.A.C. Ruby Utilities
+
+Utilities for E.A.C.'s Ruby projects.

data/sub/eac_ruby_utils/eac_ruby_utils.gemspec

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+
+# Maintain your gem's version:
+require 'eac_ruby_utils/version'
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name        = 'eac_ruby_utils'
+  s.version     = EacRubyUtils::VERSION
+  s.authors     = ['Esquilo Azul Company']
+  s.summary     = 'Utilities for E.A.C.\'s Ruby projects.'
+  s.license     = 'MIT'
+
+  s.files = Dir['{lib}/**/*', 'MIT-LICENSE', 'README.rdoc']
+  s.required_ruby_version = '>= 3.2'
+
+  s.add_dependency 'activesupport', '>= 6.1.7.10'
+  s.add_dependency 'addressable', '~> 2.9'
+  s.add_dependency 'bundler'
+  s.add_dependency 'memoized', '~> 1.1', '>= 1.1.3'
+  s.add_dependency 'net-ssh', '~> 4.2'
+  s.add_dependency 'zeitwerk', '~> 2.8', '>= 2.8.2'
+  s.add_development_dependency 'avm-eac_ubuntu_base0', '~> 0.7', '>= 0.7.1'
+  s.add_development_dependency 'eac_ruby_gem_support', '~> 0.14'
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/acts_as_abstract.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/module_ancestors_variable/hash'
+require 'eac_ruby_utils/patches/class/self_included_modules'
+require 'eac_ruby_utils/patches/module/common_concern'
+require 'eac_ruby_utils/unimplemented_method_error'
+
+module EacRubyUtils
+  # Support to abstract methods.
+  #
+  # Usage:
+  #
+  #   require 'eac_ruby_utils/acts_as_abstract'
+  #
+  #   class BaseClass
+  #     include EacRubyUtils::ActsAsAbstract
+  #
+  #     abstract_methods :mymethod
+  #   end
+  #
+  #   BaseClass.new.mymethod # raise "Abstract method: mymethod"
+  #
+  #   class SubClass
+  #     def mymethod
+  #       "Implemented"
+  #     end
+  #   end
+  #
+  #   SubClass.new.mymethod # return "Implemented"
+  module ActsAsAbstract
+    common_concern
+
+    class << self
+      def abstract?(a_class)
+        a_class.self_included_modules.include?(::EacRubyUtils::ActsAsAbstract)
+      end
+    end
+
+    module ClassMethods
+      # @param name [Symbol]
+      # @param arguments [Enumerable<Symbol>]
+      # @return [void]
+      def abstract_method(name, *arguments)
+        abstract_methods_hash[name.to_sym] = arguments
+      end
+
+      # @param methods_names [Enumerable<Object>] Each item can be a symbolizable or a hash.
+      # @return [void]
+      def abstract_methods(*methods_names)
+        methods_names.each do |method_name|
+          if method_name.is_a?(::Hash)
+            abstract_methods_from_hash(method_name)
+          else
+            abstract_method(method_name)
+          end
+        end
+      end
+
+      private
+
+      # @param hash [Hash]
+      # @return [void]
+      def abstract_methods_from_hash(hash)
+        hash.each { |name, arguments| abstract_method(name, *arguments) }
+      end
+
+      # @return [Hash<Symbol, Array]
+      def abstract_methods_hash
+        @abstract_methods_hash ||=
+          ::EacRubyUtils::ModuleAncestorsVariable::Hash.new(self, __method__)
+      end
+    end
+
+    module InstanceMethods
+      def respond_to_missing?(method_name, include_private = false)
+        super || abstract_method?(method_name)
+      end
+
+      def method_missing(method_name, *arguments, &)
+        raise_abstract_method(method_name) if abstract_method?(method_name)
+
+        super
+      end
+
+      # @param method_name [Symbol]
+      # @return [Boolean]
+      def abstract_method?(method_name)
+        return false if self.class.method_defined?(method_name)
+
+        self.class.send(:abstract_methods_hash).key?(method_name.to_sym)
+      end
+
+      def raise_abstract_method(method_name, arguments = [])
+        raise ::EacRubyUtils::UnimplementedMethodError,
+              "Abstract method #{method_name}(#{arguments.join(', ')}) hit in " \
+              "#{self}\" (Class: #{self.class})"
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/acts_as_immutable/array_accessor.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/acts_as_immutable/enumerable_accessor'
+
+module EacRubyUtils
+  module ActsAsImmutable
+    class ArrayAccessor < ::EacRubyUtils::ActsAsImmutable::EnumerableAccessor
+      INITIAL_VALUE = [].freeze
+
+      # @param value [Object]
+      # @return [Array]
+      def immutable_value_set_assert(value)
+        return value if value.is_a?(::Array)
+        return value.to_a if value.respond_to?(:to_a)
+
+        Array(value)
+      end
+
+      # @return [Array] A empty array.
+      def initial_value
+        INITIAL_VALUE
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/acts_as_immutable/base_accessor.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/object/if_respond'
+
+module EacRubyUtils
+  module ActsAsImmutable
+    class BaseAccessor
+      FILTER_GET_METHOD_NAME_FORMAT = '%s_get_filter'
+      FILTER_SET_METHOD_NAME_FORMAT = '%s_set_filter'
+
+      common_constructor :name do
+        self.name = name.to_sym
+      end
+
+      def duplicate_object(object)
+        accessor_new_value = yield(immutable_value_get(object))
+        new_values = object.send(:immutable_values_get).merge(name => accessor_new_value)
+        r = object.class.new(*object.immutable_constructor_args)
+        r.send(:immutable_values_set, new_values)
+        r
+      end
+
+      def immutable_value_get(object)
+        object.send(:immutable_values_get)[name]
+      end
+
+      # @param object [Object]
+      # @return [Object]
+      def immutable_value_get_filtered(object)
+        r = immutable_value_get(object)
+        if object.respond_to?(immutable_value_get_filtered_method_name, true)
+          r = object.send(immutable_value_get_filtered_method_name, r)
+        end
+        r
+      end
+
+      # @return [Symbol]
+      def immutable_value_get_filtered_method_name
+        format(FILTER_GET_METHOD_NAME_FORMAT, name)
+      end
+
+      # @param object [Object]
+      # @return [Object]
+      def immutable_value_set_filtered(object, value)
+        if object.respond_to?(immutable_value_set_filtered_method_name, true)
+          value = object.send(immutable_value_set_filtered_method_name, value)
+        end
+        immutable_value_set(object, value)
+      end
+
+      # @return [Symbol]
+      def immutable_value_set_filtered_method_name
+        format(FILTER_SET_METHOD_NAME_FORMAT, name)
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/acts_as_immutable/boolean_accessor.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/acts_as_immutable/common_accessor'
+require 'eac_ruby_utils/patches/class/common_constructor'
+
+module EacRubyUtils
+  module ActsAsImmutable
+    class BooleanAccessor < ::EacRubyUtils::ActsAsImmutable::CommonAccessor
+      def apply(klass)
+        super
+        accessor = self
+        klass.send(:define_method, "#{name}?") { send(accessor.name) }
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/acts_as_immutable/class_methods.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  module ActsAsImmutable
+    module ClassMethods
+      def immutable_accessor(*accessors)
+        options = accessors.extract_options!
+        options[:type] ||= const_get('TYPE_COMMON')
+        accessors.each do |name|
+          class_name = "#{options.fetch(:type).to_s.camelize}Accessor"
+          ::EacRubyUtils::ActsAsImmutable.const_get(class_name).new(name).apply(self)
+        end
+      end
+
+      private
+
+      def imutable_single_accessor(name, options); end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/acts_as_immutable/common_accessor.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/acts_as_immutable/base_accessor'
+require 'eac_ruby_utils/patches/class/common_constructor'
+
+module EacRubyUtils
+  module ActsAsImmutable
+    class CommonAccessor < ::EacRubyUtils::ActsAsImmutable::BaseAccessor
+      def apply(klass)
+        accessor = self
+        klass.send(:define_method, name) do |*args|
+          case args.count
+          when 0 then next accessor.immutable_value_get_filtered(self)
+          when 1 then next accessor.immutable_value_set_filtered(self, args.first)
+          else
+            raise ::ArgumentError, "wrong number of arguments (given #{args.count}, expected 0..1)"
+          end
+        end
+      end
+
+      def immutable_value_get(object)
+        object.send(:immutable_values_get)[name]
+      end
+
+      def immutable_value_set(object, value)
+        duplicate_object(object) { |_old_value| value }
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/acts_as_immutable/enumerable_accessor.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+require 'eac_ruby_utils/acts_as_immutable/base_accessor'
+require 'eac_ruby_utils/patches/class/common_constructor'
+
+module EacRubyUtils
+  module ActsAsImmutable
+    # Should implement in concrect classes:
+    # * immutable_value_set_assert(value)
+    # * initial_value()
+    class EnumerableAccessor < ::EacRubyUtils::ActsAsImmutable::BaseAccessor
+      def apply(klass)
+        apply_singular(klass)
+        apply_plural(klass)
+      end
+
+      def apply_plural(klass)
+        accessor = self
+        klass.send(:define_method, ::ActiveSupport::Inflector.pluralize(name)) do |*args|
+          case args.count
+          when 0 then next accessor.immutable_value_get_filtered(self)
+          when 1 then next accessor.immutable_value_set_filtered(self, args.first)
+          else
+            raise ::ArgumentError, "wrong number of arguments (given #{args.count}, expected 0..1)"
+          end
+        end
+      end
+
+      def apply_singular(klass)
+        accessor = self
+        klass.send(:define_method, name) do |value|
+          accessor.immutable_value_push(self, value)
+        end
+      end
+
+      def immutable_value_get(object)
+        super || initial_value.dup
+      end
+
+      def immutable_value_push(object, value)
+        duplicate_object(object) do |old_value|
+          (old_value || initial_value.dup) + [value]
+        end
+      end
+
+      def immutable_value_set(object, value)
+        duplicate_object(object) { |_old_value| immutable_value_set_assert(value) }
+      end
+    end
+  end
+end