eac_tools 0.66.0 → 0.67.0

data/sub/eac_cli/lib/eac_cli/runner/after_class_methods.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'eac_cli/definition'
+require 'eac_cli/definition/error'
 require 'eac_cli/runner/class_runner'
 
 module EacCli
@@ -21,7 +22,11 @@ module EacCli
 
       def runner_definition(&block)
         @runner_definition ||= super_runner_definition
-        @runner_definition.instance_eval(&block) if block
+        begin
+          @runner_definition.instance_eval(&block) if block
+        rescue ::EacCli::Definition::Error => _e
+          raise ::EacCli::Definition::Error, "Definition error for #{self}"
+        end
         @runner_definition
       end
 

data/sub/eac_cli/lib/eac_cli/runner/context.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 require 'eac_ruby_utils/core_ext'
+require 'eac_cli/runner/context_responders/parent'
+require 'eac_cli/runner/context_responders/runner'
+require 'eac_cli/runner/context_responders/runner_missing_method'
+require 'eac_cli/runner/context_responders/set'
 
 module EacCli
   module Runner
@@ -17,10 +21,19 @@ module EacCli
 
       # Call a method in the runner or in one of it ancestors.
       def call(method_name, *args)
-        return runner.send(method_name, *args) if runner.respond_to?(method_name)
-        return parent_call(method_name, *args) if parent_respond_to?(method_name)
+        context_call_responder(method_name).call(*args)
+      end
+
+      # @return [EacCli::Runner::ContextResponders]
+      def context_call_responder(method_name)
+        ::EacCli::Runner::ContextResponders::Set.new(self, method_name, %i[runner parent])
+      end
 
-        raise ::NameError, "No method \"#{method_name}\" found in #{runner} or in its ancestors"
+      # @param method_name [Symbol]
+      # @return [EacCli::Runner::ContextResponders::Parent]
+      def runner_missing_method_responder(method_name)
+        ::EacCli::Runner::ContextResponders::RunnerMissingMethod
+          .new(self, method_name)
       end
 
       # @param method_name [Symbol]
@@ -38,6 +51,12 @@ module EacCli
 
         raise "Parent #{parent} do not respond to .context or .runner_context (Runner: #{runner})"
       end
+
+      # @param method_name [Symbol]
+      # @return [EacCli::Runner::ContextResponders::Parent]
+      def parent_responder(method_name)
+        ::EacCli::Runner::ContextResponders::Parent.new(self, method_name)
+      end
     end
   end
 end

data/sub/eac_cli/lib/eac_cli/runner/context_responders/base.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  module Runner
+    module ContextResponders
+      class Base
+        acts_as_abstract :call, :callable?
+        common_constructor :context, :method_name do
+          self.method_name = method_name.to_sym
+        end
+        delegate :parent, :runner, to: :context
+
+        def if_callable
+          return false unless callable?
+
+          yield(self)
+          true
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/runner/context_responders/parent.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_cli/runner/context_responders/base'
+
+module EacCli
+  module Runner
+    module ContextResponders
+      class Parent < ::EacCli::Runner::ContextResponders::Base
+        def callable?
+          parent.if_present(false) do |v|
+            next true if v.respond_to?(method_name)
+
+            v.if_respond(:runner_context, false) { |w| w.parent_respond_to?(method_name) }
+          end
+        end
+
+        def call(*args, &block)
+          return parent.runner_context.call(method_name, *args, &block) if
+            parent.respond_to?(:runner_context)
+
+          raise "Parent #{parent} do not respond to .context or .runner_context (Runner: #{runner})"
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/runner/context_responders/runner.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_cli/runner/context_responders/base'
+
+module EacCli
+  module Runner
+    module ContextResponders
+      class Runner < ::EacCli::Runner::ContextResponders::Base
+        def callable?
+          runner.respond_to?(method_name)
+        end
+
+        def call(*args, &block)
+          runner.send(method_name, *args, &block)
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/runner/context_responders/runner_missing_method.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_cli/runner/context_responders/base'
+
+module EacCli
+  module Runner
+    module ContextResponders
+      class RunnerMissingMethod < ::EacCli::Runner::ContextResponders::Base
+        def callable?
+          responder_runner.present?
+        end
+
+        def call(*args, &block)
+          responder_runner.send(method_name, *args, &block)
+        end
+
+        private
+
+        def responder_runner
+          parent.if_present(nil) do |v|
+            next v if v.respond_to?(method_name) && v.for_context?(method_name)
+
+            v.if_respond(:runner_context, nil) do |w|
+              w.runner_missing_method_responder(method_name).send(__method__)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/runner/context_responders/set.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_cli/runner/context_responders/base'
+
+module EacCli
+  module Runner
+    module ContextResponders
+      class Set < ::EacCli::Runner::ContextResponders::Base
+        attr_reader :responders_names
+
+        def initialize(context, method_name, responders_names)
+          super(context, method_name)
+          @responders_names = responders_names
+        end
+
+        def callable?
+          responders_instances.any?(&:callable?)
+        end
+
+        def call(*args, &block)
+          caller = responder_to_call
+          return caller.call(*args, &block) if caller
+
+          raise ::NameError, "No method \"#{method_name}\" found in #{runner} or in its ancestors"
+        end
+
+        private
+
+        def responder_class(class_name)
+          ::EacCli::Runner::ContextResponders.const_get(class_name.to_s.camelize)
+        end
+
+        def responders_instances
+          responders_names.lazy.map { |name| responder_class(name).new(context, method_name) }
+        end
+
+        def responder_to_call
+          responders_instances.lazy.select(&:callable?).first
+        end
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/runner/context_responders.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacCli
+  module Runner
+    module ContextResponders
+      require_sub __FILE__
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/runner/for_context.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/module_ancestors_variable/set'
+
+module EacCli
+  module Runner
+    module ForContext
+      common_concern
+
+      module ClassMethods
+        # @param methods_names [Enumerable<Symbol>]
+        # @return [void]
+        def for_context(*methods_names)
+          for_context_methods.merge(methods_names.map(&:to_sym))
+        end
+
+        # @param method_name [Symbol]
+        # @return [Boolean]
+        def for_context?(method_name)
+          for_context_methods.include?(method_name.to_sym)
+        end
+
+        private
+
+        # @return [EacRubyUtils::ModuleAncestorsVariable::Set<Symbol>]
+        def for_context_methods
+          @for_context_methods ||=
+            ::EacRubyUtils::ModuleAncestorsVariable::Set.new(self, __method__)
+        end
+      end
+
+      # @param method_name [Symbol]
+      # @return [Boolean]
+      def for_context?(method_name)
+        self.class.for_context?(method_name)
+      end
+    end
+  end
+end

data/sub/eac_cli/lib/eac_cli/runner/instance_methods.rb

@@ -30,13 +30,15 @@ module EacCli
       end
 
       def respond_to_missing?(method, include_all = false)
-        runner_context.parent_respond_to?(method) || super
+        runner_context.runner_missing_method_responder(method).callable? || super
       end
 
       def method_missing(method, *args, &block)
-        return super unless runner_context.parent_respond_to?(method)
+        runner_context.runner_missing_method_responder(method).if_callable do |v|
+          return v.call(*args, &block)
+        end
 
-        runner_context.parent_call(method, *args, &block)
+        super
       end
     end
   end

data/sub/eac_cli/lib/eac_cli/runner.rb

@@ -42,6 +42,7 @@ module EacCli
 
       extend AfterClassMethods
       include InstanceMethods
+      include ::EacCli::Runner::ForContext
       include ActiveSupport::Callbacks
       define_callbacks :run
     end

data/sub/eac_cli/lib/eac_cli/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacCli
-  VERSION = '0.34.0'
+  VERSION = '0.35.0'
 end

data/sub/eac_cli/spec/lib/eac_cli/runner/for_context_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'eac_cli/runner'
+
+::RSpec.describe ::EacCli::Runner do
+  let(:parent_runner_class) do
+    example = self
+    ::Class.new do
+      include example.described_class
+
+      def self.name
+        'ParentRunnerClass'
+      end
+
+      for_context :method_for_context
+
+      def run; end
+
+      def method_for_context; end
+
+      def method_not_for_context; end
+    end
+  end
+
+  let(:child_runner_class_1) do
+    example = self
+    ::Class.new do
+      include example.described_class
+
+      def self.name
+        'ChildRunnerClass1'
+      end
+
+      def run
+        method_for_context
+        runner_context.call(:method_for_context)
+        runner_context.call(:method_not_for_context)
+      end
+    end
+  end
+
+  let(:child_runner_class_2) do
+    example = self
+    ::Class.new do
+      include example.described_class
+
+      def self.name
+        'ChildRunnerClass2'
+      end
+
+      def run
+        method_not_for_context
+      end
+    end
+  end
+
+  let(:parent_runner) { parent_runner_class.create }
+  let(:context_args) { [{ argv: [], parent: parent_runner }] }
+  let(:child_runner) { child_runner_class.create(*context_args) }
+
+  it { expect(parent_runner.for_context?(:method_for_context)).to eq(true) }
+  it { expect(parent_runner.for_context?(:method_not_for_context)).to eq(false) }
+
+  context 'when method is for context' do
+    let(:child_runner_class) { child_runner_class_1 }
+
+    it do
+      expect { child_runner.run }.not_to raise_error
+    end
+  end
+
+  context 'when method is not for context' do
+    let(:child_runner_class) { child_runner_class_2 }
+
+    it do
+      expect { child_runner.run }.to raise_error(::NameError)
+    end
+  end
+end

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

@@ -19,6 +19,7 @@ RSpec.describe ::EacCli::RunnerWith::Subcommands do
       end
 
       delegate :root_var, to: :parsed
+      for_context :method_in_parent_runner
 
       def method_in_parent_runner; end
     end

data/sub/eac_ruby_base0/eac_ruby_base0.gemspec

@@ -12,10 +12,10 @@ Gem::Specification.new do |s|
 
   s.files = Dir['{lib}/**/*']
 
-  s.add_dependency 'avm-eac_ruby_base1', '~> 0.30', '>= 0.30.2'
-  s.add_dependency 'eac_cli', '~> 0.31'
+  s.add_dependency 'avm-eac_ruby_base1', '~> 0.30', '>= 0.30.3'
+  s.add_dependency 'eac_cli', '~> 0.35'
   s.add_dependency 'eac_fs', '~> 0.16'
-  s.add_dependency 'eac_ruby_utils', '~> 0.112'
+  s.add_dependency 'eac_ruby_utils', '~> 0.117'
 
   s.add_development_dependency 'eac_ruby_gem_support', '~> 0.5.1'
 end

data/sub/eac_ruby_base0/lib/eac_ruby_base0/runner/contexts.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'eac_config/node'
+require 'eac_fs/contexts'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/speaker'
+
+module EacRubyBase0
+  module Runner
+    module Contexts
+      def on_context(&block)
+        top_block = block
+        available_contexts.each do |context|
+          next if context.object.any?
+
+          last_block = top_block
+          top_block = ::Proc.new { context.object.on(context.builder.call, &last_block) }
+        end
+        top_block.call
+      end
+
+      private
+
+      # @return [Array<EacRubyUtils::Struct>]
+      def available_contexts
+        (filesystem_available_contexts + [
+          [:config, ::EacConfig::Node.context,
+           -> { runner_context.call(:application).build_config }],
+          [:speaker, ::EacRubyUtils::Speaker.context, -> { build_speaker }]
+        ]).map { |row| available_context_row_to_struct(row) }
+      end
+
+      def available_context_row_to_struct(row)
+        %i[type object builder].zip(row).to_h.to_struct
+      end
+
+      def build_speaker
+        options = {}
+        options[:err_out] = ::StringIO.new if parsed.quiet?
+        options[:in_in] = ::EacCli::Speaker::InputBlocked.new if parsed.no_input?
+        ::EacCli::Speaker.new(options)
+      end
+
+      def filesystem_available_contexts
+        ::EacFs::Contexts::TYPES.map do |type|
+          key = "fs_#{type}".to_sym
+          [key, ::EacFs::Contexts.send(type), -> { application.send("self_#{key}") }]
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_base0/lib/eac_ruby_base0/runner/prepend.rb

@@ -10,17 +10,30 @@ require 'eac_ruby_utils/speaker'
 module EacRubyBase0
   module Runner
     module Prepend
+      SYSTEM_STACK_ERROR_FILE = 'system_stack_error'
+
       def run
-        if parsed.version?
-          show_version
-        else
-          run_with_subcommand
+        on_rescue_stack_overflow do
+          if parsed.version?
+            show_version
+          else
+            run_with_subcommand
+          end
         end
       end
 
       def run_run
         on_context { super }
       end
+
+      private
+
+      def on_rescue_stack_overflow
+        yield
+      rescue ::SystemStackError => e
+        SYSTEM_STACK_ERROR_FILE.to_pathname.write(e.backtrace.map { |v| "#{v}\n" }.join)
+        raise e
+      end
     end
   end
 end

data/sub/eac_ruby_base0/lib/eac_ruby_base0/runner.rb

@@ -14,6 +14,7 @@ module EacRubyBase0
     common_concern do
       include ::EacCli::RunnerWith::Help
       include ::EacCli::RunnerWith::Subcommands
+      include ::EacRubyBase0::Runner::Contexts
       prepend ::EacRubyBase0::Runner::Prepend
       runner_definition do
         bool_opt '-q', '--quiet', 'Quiet mode.'
@@ -29,47 +30,8 @@ module EacRubyBase0
       runner_context.call(:application).version.to_s
     end
 
-    def on_context(&block)
-      top_block = block
-      available_contexts.each do |context|
-        next if context.object.any?
-
-        last_block = top_block
-        top_block = ::Proc.new { context.object.on(context.builder.call, &last_block) }
-      end
-      top_block.call
-    end
-
     def show_version
       out("#{application_version}\n")
     end
-
-    private
-
-    # @return [Array<EacRubyUtils::Struct>]
-    def available_contexts
-      (filesystem_available_contexts + [
-        [:config, ::EacConfig::Node.context, -> { runner_context.call(:application).build_config }],
-        [:speaker, ::EacRubyUtils::Speaker.context, -> { build_speaker }]
-      ]).map { |row| available_context_row_to_struct(row) }
-    end
-
-    def available_context_row_to_struct(row)
-      %i[type object builder].zip(row).to_h.to_struct
-    end
-
-    def build_speaker
-      options = {}
-      options[:err_out] = ::StringIO.new if parsed.quiet?
-      options[:in_in] = ::EacCli::Speaker::InputBlocked.new if parsed.no_input?
-      ::EacCli::Speaker.new(options)
-    end
-
-    def filesystem_available_contexts
-      ::EacFs::Contexts::TYPES.map do |type|
-        key = "fs_#{type}".to_sym
-        [key, ::EacFs::Contexts.send(type), -> { application.send("self_#{key}") }]
-      end
-    end
   end
 end

data/sub/eac_ruby_base0/lib/eac_ruby_base0/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacRubyBase0
-  VERSION = '0.18.0'
+  VERSION = '0.19.0'
 end

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

@@ -1,7 +1,9 @@
 # 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.
@@ -39,9 +41,7 @@ module EacRubyUtils
       # @param arguments [Enumerable<Symbol>]
       # @return [void]
       def abstract_method(name, *arguments)
-        define_method name.to_sym do |*_the_args|
-          raise_abstract_method(name.to_sym, arguments)
-        end
+        abstract_methods_hash[name.to_sym] = arguments
       end
 
       # @param methods_names [Enumerable<Object>] Each item can be a symbolizable or a hash.
@@ -63,6 +63,12 @@ module EacRubyUtils
       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
@@ -76,13 +82,18 @@ module EacRubyUtils
         super
       end
 
+      # @param method_name [Symbol]
+      # @return [Boolean]
       def abstract_method?(method_name)
-        self.class.abstract_methods.include?(method_name.to_sym)
+        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 ::NoMethodError, "Abstract method #{method_name}(#{arguments.join(', ')}) hit in " \
-          "#{self}\" (Class: #{self.class})"
+        raise ::EacRubyUtils::UnimplementedMethodError,
+              "Abstract method #{method_name}(#{arguments.join(', ')}) hit in " \
+              "#{self}\" (Class: #{self.class})"
       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