eac_tools 0.66.0 → 0.67.1

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

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/{immutable → acts_as_immutable}/boolean_accessor.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'eac_ruby_utils/immutable/common_accessor'
+require 'eac_ruby_utils/acts_as_immutable/common_accessor'
 require 'eac_ruby_utils/patches/class/common_constructor'
 
 module EacRubyUtils
-  module Immutable
-    class BooleanAccessor < ::EacRubyUtils::Immutable::CommonAccessor
+  module ActsAsImmutable
+    class BooleanAccessor < ::EacRubyUtils::ActsAsImmutable::CommonAccessor
       def apply(klass)
         super
         accessor = self

data/sub/eac_ruby_utils/lib/eac_ruby_utils/{immutable → acts_as_immutable}/class_methods.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 module EacRubyUtils
-  module Immutable
+  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::Immutable.const_get(class_name).new(name).apply(self)
+          ::EacRubyUtils::ActsAsImmutable.const_get(class_name).new(name).apply(self)
         end
       end
 

data/sub/eac_ruby_utils/lib/eac_ruby_utils/{immutable → acts_as_immutable}/common_accessor.rb

@@ -1,17 +1,17 @@
 # frozen_string_literal: true
 
-require 'eac_ruby_utils/immutable/base_accessor'
+require 'eac_ruby_utils/acts_as_immutable/base_accessor'
 require 'eac_ruby_utils/patches/class/common_constructor'
 
 module EacRubyUtils
-  module Immutable
-    class CommonAccessor < ::EacRubyUtils::Immutable::BaseAccessor
+  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(self)
-          when 1 then next accessor.immutable_value_set(self, args.first)
+          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

data/sub/eac_ruby_utils/lib/eac_ruby_utils/{immutable/array_accessor.rb → acts_as_immutable/enumerable_accessor.rb}

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 
 require 'active_support/inflector'
-require 'eac_ruby_utils/immutable/base_accessor'
+require 'eac_ruby_utils/acts_as_immutable/base_accessor'
 require 'eac_ruby_utils/patches/class/common_constructor'
 
 module EacRubyUtils
-  module Immutable
-    class ArrayAccessor < ::EacRubyUtils::Immutable::BaseAccessor
+  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)
@@ -16,8 +19,8 @@ module EacRubyUtils
         accessor = self
         klass.send(:define_method, ::ActiveSupport::Inflector.pluralize(name)) do |*args|
           case args.count
-          when 0 then next accessor.immutable_value_get(self)
-          when 1 then next accessor.immutable_value_set(self, args.first)
+          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
@@ -32,17 +35,17 @@ module EacRubyUtils
       end
 
       def immutable_value_get(object)
-        super || []
+        super || initial_value.dup
       end
 
       def immutable_value_push(object, value)
         duplicate_object(object) do |old_value|
-          (old_value || []) + [value]
+          (old_value || initial_value.dup) + [value]
         end
       end
 
       def immutable_value_set(object, value)
-        duplicate_object(object) { |_old_value| value }
+        duplicate_object(object) { |_old_value| immutable_value_set_assert(value) }
       end
     end
   end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/{immutable → acts_as_immutable}/hash_accessor.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'eac_ruby_utils/immutable/base_accessor'
+require 'eac_ruby_utils/acts_as_immutable/base_accessor'
 require 'eac_ruby_utils/patches/class/common_constructor'
 
 module EacRubyUtils
-  module Immutable
-    class HashAccessor < ::EacRubyUtils::Immutable::BaseAccessor
+  module ActsAsImmutable
+    class HashAccessor < ::EacRubyUtils::ActsAsImmutable::BaseAccessor
       def apply(klass)
         apply_plural(klass)
         apply_singular(klass)
@@ -33,8 +33,8 @@ module EacRubyUtils
         accessor = self
         klass.send(:define_method, ::ActiveSupport::Inflector.pluralize(name)) do |*args|
           case args.count
-          when 0 then next accessor.immutable_value_get(self)
-          when 1 then next accessor.immutable_value_set(self, args[0])
+          when 0 then next accessor.immutable_value_get_filtered(self)
+          when 1 then next accessor.immutable_value_set_filtered(self, args[0])
           else
             raise ::ArgumentError, "wrong number of arguments (given #{args.count}, expected 0..1)"
           end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/{immutable → acts_as_immutable}/instance_methods.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module EacRubyUtils
-  module Immutable
+  module ActsAsImmutable
     module InstanceMethods
       def immutable_constructor_args
         []

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

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

data/sub/eac_ruby_utils/lib/eac_ruby_utils/{immutable.rb → acts_as_immutable.rb}

@@ -4,7 +4,7 @@ require 'eac_ruby_utils/patches/module/common_concern'
 require 'eac_ruby_utils/require_sub'
 
 module EacRubyUtils
-  module Immutable
+  module ActsAsImmutable
     ::EacRubyUtils.require_sub __FILE__
 
     common_concern do

data/sub/eac_ruby_utils/lib/eac_ruby_utils/enumerables_methods.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/object/debug'
+
+module EacRubyUtils
+  module EnumerablesMethods
+    class << self
+      WRITE_METHOD_PATTERNS = [/\A[a-z].*[\!\=]\z/i] +
+                              %i[\[\]= <<].map { |m| /\A#{::Regexp.quote(m)}\z/ } +
+                              %i[add clear delete divide keep reset shift subtract]
+                                .map { |m| /\A#{::Regexp.quote(m)}.*\z/ }
+
+      # @param klass [Klass]
+      # @return [Enumerable<Symbol>]
+      def self_methods_names(klass)
+        (klass.public_instance_methods - klass.superclass.public_instance_methods).sort
+      end
+
+      # @param method_name [Symbol]
+      # @return [Boolean]
+      def write_method?(method_name)
+        WRITE_METHOD_PATTERNS.any? { |pattern| pattern.match?(method_name.to_s) }
+      end
+    end
+
+    ARRAY_METHODS = self_methods_names(::Array)
+    ARRAY_WRITE_METHODS = ARRAY_METHODS.select { |m| write_method?(m) }
+    ARRAY_READ_METHODS = ARRAY_METHODS - ARRAY_WRITE_METHODS
+
+    ENUMERABLE_METHODS = ::Enumerable.public_instance_methods.sort
+    ENUMERABLE_WRITE_METHODS = ENUMERABLE_METHODS.select { |m| write_method?(m) }
+    ENUMERABLE_READ_METHODS = ENUMERABLE_METHODS - ENUMERABLE_WRITE_METHODS
+
+    HASH_METHODS = self_methods_names(::Hash)
+    HASH_WRITE_METHODS = HASH_METHODS.select { |m| write_method?(m) }
+    HASH_READ_METHODS = HASH_METHODS - HASH_WRITE_METHODS
+
+    SET_METHODS = self_methods_names(::Set)
+    SET_WRITE_METHODS = SET_METHODS.select { |m| write_method?(m) } + [:merge]
+    SET_READ_METHODS = SET_METHODS - SET_WRITE_METHODS
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/module_ancestors_variable/base.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/class/common_constructor'
+
+module EacRubyUtils
+  module ModuleAncestorsVariable
+    class Base
+      common_constructor :the_module, :method_name, :initial_value
+
+      # @param current [Object]
+      # @param other [Object]
+      # @return [Object]
+      def merge_operation(current, other)
+        current.merge(other)
+      end
+
+      # return [Hash]
+      def ancestors_variable
+        the_module.ancestors.inject(initial_value.dup) do |a, e|
+          if e.respond_to?(method_name, true)
+            merge_operation(a, e.send(method_name).send(:self_variable))
+          else
+            a
+          end
+        end
+      end
+
+      # @return [Hash]
+      def self_variable
+        @self_variable ||= initial_value.dup
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/module_ancestors_variable/hash.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/delegation'
+require 'eac_ruby_utils/module_ancestors_variable/base'
+require 'eac_ruby_utils/enumerables_methods'
+
+module EacRubyUtils
+  module ModuleAncestorsVariable
+    class Hash < ::EacRubyUtils::ModuleAncestorsVariable::Base
+      INITIAL_VALUE = {}.freeze
+
+      def initialize(the_module, method_name)
+        super(the_module, method_name, INITIAL_VALUE)
+      end
+
+      delegate(*::EacRubyUtils::EnumerablesMethods::HASH_READ_METHODS, to: :ancestors_variable)
+      delegate(*::EacRubyUtils::EnumerablesMethods::HASH_WRITE_METHODS, to: :self_variable)
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/module_ancestors_variable/set.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/delegation'
+require 'eac_ruby_utils/module_ancestors_variable/base'
+
+module EacRubyUtils
+  module ModuleAncestorsVariable
+    class Set < ::EacRubyUtils::ModuleAncestorsVariable::Base
+      INITIAL_VALUE = ::Set.new
+
+      def initialize(the_module, method_name)
+        super(the_module, method_name, INITIAL_VALUE)
+      end
+
+      delegate(*::EacRubyUtils::EnumerablesMethods::SET_READ_METHODS, to: :ancestors_variable)
+      delegate(*::EacRubyUtils::EnumerablesMethods::SET_WRITE_METHODS, to: :self_variable)
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/module_ancestors_variable.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/require_sub'
+
+module EacRubyUtils
+  class ModuleAncestorsHash
+    require_sub __FILE__
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/module/acts_as_immutable.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patch'
+require 'eac_ruby_utils/acts_as_immutable'
+
+class Module
+  def acts_as_immutable
+    ::EacRubyUtils.patch(self, ::EacRubyUtils::ActsAsImmutable)
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/module/immutable.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 require 'eac_ruby_utils/patch'
-require 'eac_ruby_utils/immutable'
+require 'eac_ruby_utils/acts_as_immutable'
 
 class Module
+  # @deprecated Use {#acts_as_immutable} instead.
   def enable_immutable
-    ::EacRubyUtils.patch(self, ::EacRubyUtils::Immutable)
+    ::EacRubyUtils.patch(self, ::EacRubyUtils::ActsAsImmutable)
   end
 end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patches/object/debug.rb

@@ -1,6 +1,15 @@
 # frozen_string_literal: true
 
+require 'eac_ruby_utils/patches/object/if_present'
+require 'pp'
+
 class Object
+  def compact_debug(*methods_names)
+    methods_names.each do |method_name|
+      send(method_name).print_debug(label: method_name)
+    end
+  end
+
   def pretty_debug(options = {})
     print_debug_options(options)
 

data/sub/eac_ruby_utils/lib/eac_ruby_utils/unimplemented_method_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module EacRubyUtils
+  class UnimplementedMethodError < ::StandardError
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacRubyUtils
-  VERSION = '0.116.0'
+  VERSION = '0.117.0'
 end