eac_tools 0.66.0 → 0.67.0

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

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/acts_as_abstract_spec.rb

@@ -1,28 +1,94 @@
 # frozen_string_literal: true
 
 require 'eac_ruby_utils/acts_as_abstract'
+require 'eac_ruby_utils/unimplemented_method_error'
 
-RSpec.describe(::EacRubyUtils::ActsAsAbstract) do
+::RSpec.describe(::EacRubyUtils::ActsAsAbstract) do
   let(:base_class) do
     the_module = described_class
     ::Class.new do
       include the_module
 
       abstract_methods :method1, :method2
+
+      def method3
+        'base result'
+      end
     end
   end
-  let(:base_instance) { base_class.new }
   let(:sub_class) do
     ::Class.new(base_class) do
       def method1
         'a result'
       end
+
+      def method4
+        'sub result'
+      end
     end
   end
-  let(:sub_instance) { sub_class.new }
 
-  it { expect { base_instance.method1 }.to raise_error(::NoMethodError) }
-  it { expect { base_instance.method2 }.to raise_error(::NoMethodError) }
-  it { expect(sub_instance.method1).to eq('a result') }
-  it { expect { sub_instance.method2 }.to raise_error(::NoMethodError) }
+  class << self
+    def specs_for_target(test_target, instances_hash)
+      describe "\##{test_target}" do # rubocop:disable RSpec/EmptyExampleGroup
+        specs_for_instances(test_target, instances_hash)
+      end
+    end
+
+    def specs_for_instances(test_target, instances_hash)
+      instances_hash.each do |instance_name, expected_values|
+        context "when instance is \"#{instance_name}\"" do # rubocop:disable RSpec/EmptyExampleGroup
+          let(:instance) { send("#{instance_name}_class").new }
+
+          specs_for_methods_values(test_target, expected_values)
+        end
+      end
+    end
+
+    def specs_for_methods_values(test_target, expected_values)
+      expected_values.each_with_index do |expected_value, method_index|
+        method_name = "method#{method_index + 1}"
+        context "when method is \"#{method_name}\"" do # rubocop:disable RSpec/EmptyExampleGroup
+          send("specs_for_#{test_target}", method_name, expected_value)
+        end
+      end
+    end
+
+    def specs_for_abstract_method(method_name, expected_value)
+      it { expect(instance.abstract_method?(method_name)).to eq(expected_value) }
+    end
+
+    def specs_for_method_missing(method_name, expected_value)
+      if expected_value.is_a?(::Class) && expected_value < ::Exception
+        it do
+          expect { instance.send(method_name) }.to raise_error(expected_value)
+        end
+      else
+        it do
+          expect(instance.send(method_name)).to eq(expected_value)
+        end
+      end
+    end
+
+    def specs_for_respond_to_missing(method_name, expected_value)
+      it { expect(instance.respond_to?(method_name)).to eq(expected_value) }
+    end
+  end
+  {
+    abstract_method: {
+      base: [true, true, false, false],
+      sub: [false, true, false, false]
+    },
+    method_missing: {
+      base: [::EacRubyUtils::UnimplementedMethodError, ::EacRubyUtils::UnimplementedMethodError,
+             'base result', ::NoMethodError],
+      sub: ['a result', ::EacRubyUtils::UnimplementedMethodError, 'base result', 'sub result']
+    },
+    respond_to_missing: {
+      base: [true, true, true, false],
+      sub: [true, true, true, true]
+    }
+  }.each do |test_target, instances_hash|
+    specs_for_target(test_target, instances_hash)
+  end
 end

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

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'eac_ruby_utils/immutable'
+require 'eac_ruby_utils/acts_as_immutable'
 
-::RSpec.describe ::EacRubyUtils::Immutable::ArrayAccessor do
+::RSpec.describe ::EacRubyUtils::ActsAsImmutable::ArrayAccessor do
   let(:stub_class) do
     ::Class.new do
-      include ::EacRubyUtils::Immutable
+      include ::EacRubyUtils::ActsAsImmutable
 
       immutable_accessor :array_attr, type: :array
     end
@@ -31,5 +31,13 @@ require 'eac_ruby_utils/immutable'
       it { expect(change2_instance.object_id).not_to eq(change1_instance.object_id) }
       it { expect(change2_instance.array_attrs).to eq(%w[B]) }
     end
+
+    context 'when array_attrs sets for a non array' do
+      let(:change2_instance) { initial_instance.array_attrs('B') }
+
+      it { expect(change2_instance).to be_a(initial_instance.class) }
+      it { expect(change2_instance.object_id).not_to eq(change1_instance.object_id) }
+      it { expect(change2_instance.array_attrs).to eq(%w[B]) }
+    end
   end
 end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/acts_as_immutable/common_accessor_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/acts_as_immutable'
+
+::RSpec.describe ::EacRubyUtils::ActsAsImmutable::CommonAccessor do
+  let(:stub_class) do
+    ::Class.new do
+      include ::EacRubyUtils::ActsAsImmutable
+
+      immutable_accessor :attr1, :attr2, :attr3
+
+      def attr1_get_filter(value)
+        value || 'DEFAULT'
+      end
+
+      def attr2_set_filter(value)
+        "#{value}_FILTERED"
+      end
+    end
+  end
+
+  let(:initial_instance) { stub_class.new }
+
+  it { expect(initial_instance.attr1).to eq('DEFAULT') }
+  it { expect(initial_instance.attr2).to eq(nil) }
+  it { expect(initial_instance.attr3).to eq(nil) }
+
+  context 'when attr1 is set' do
+    let(:change1_instance) { initial_instance.attr1('A') }
+
+    it { expect(change1_instance).to be_a(initial_instance.class) }
+    it { expect(change1_instance.object_id).not_to eq(initial_instance.object_id) }
+    it { expect(change1_instance.attr1).to eq('A') }
+    it { expect(change1_instance.attr2).to eq(nil) }
+    it { expect(change1_instance.attr3).to eq(nil) }
+
+    context 'when attr2 is set' do
+      let(:change2_instance) { change1_instance.attr2('B') }
+
+      it { expect(change2_instance).to be_a(change1_instance.class) }
+      it { expect(change2_instance.object_id).not_to eq(change1_instance.object_id) }
+      it { expect(change2_instance.attr1).to eq('A') }
+      it { expect(change2_instance.attr2).to eq('B_FILTERED') }
+      it { expect(change2_instance.attr3).to eq(nil) }
+    end
+
+    context 'when attr3 is set' do
+      let(:change2_instance) { change1_instance.attr3('C') }
+
+      it { expect(change2_instance).to be_a(change1_instance.class) }
+      it { expect(change2_instance.object_id).not_to eq(change1_instance.object_id) }
+      it { expect(change2_instance.attr1).to eq('A') }
+      it { expect(change2_instance.attr2).to eq(nil) }
+      it { expect(change2_instance.attr3).to eq('C') }
+    end
+  end
+end

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

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'eac_ruby_utils/immutable'
+require 'eac_ruby_utils/acts_as_immutable'
 
-::RSpec.describe ::EacRubyUtils::Immutable::HashAccessor do
+::RSpec.describe ::EacRubyUtils::ActsAsImmutable::HashAccessor do
   let(:stub_class) do
     ::Class.new do
-      include ::EacRubyUtils::Immutable
+      include ::EacRubyUtils::ActsAsImmutable
 
       immutable_accessor :the_hash, type: :hash
     end