eac_tools 0.24.0 → 0.25.1

data/sub/avm-eac_webapp_base0/lib/avm/eac_webapp_base0/version.rb

@@ -2,6 +2,6 @@
 
 module Avm
   module EacWebappBase0
-    VERSION = '0.4.0'
+    VERSION = '0.5.0'
   end
 end

data/sub/eac_config/eac_config.gemspec

@@ -12,8 +12,8 @@ Gem::Specification.new do |s|
 
   s.files = Dir['{lib}/**/*']
 
-  s.add_dependency 'addressable'
-  s.add_dependency 'eac_ruby_utils', '~> 0.97'
+  s.add_dependency 'addressable', '~> 2.8'
+  s.add_dependency 'eac_ruby_utils', '~> 0.102'
 
   s.add_development_dependency 'eac_ruby_gem_support', '~> 0.5.1'
 end

data/sub/eac_config/lib/eac_config/entry.rb

@@ -22,6 +22,10 @@ module EacConfig
       node_entry.if_present(&:secret_value)
     end
 
+    def to_s
+      "#{self.class}[RootNode: #{root_node}, Path: #{path}]"
+    end
+
     def value
       node_entry.if_present(&:value)
     end

data/sub/eac_config/lib/eac_config/entry_path.rb

@@ -51,7 +51,12 @@ module EacConfig
     end
 
     def to_s
-      "#{self.class}[#{parts.join(PART_SEPARATOR)}]"
+      "#{self.class}[#{to_string}]"
+    end
+
+    # @return [String]
+    def to_string
+      parts.join(PART_SEPARATOR)
     end
   end
 end

data/sub/eac_config/lib/eac_config/envvars_node.rb

@@ -21,5 +21,9 @@ module EacConfig
     def url
       URI
     end
+
+    def to_s
+      "#{self.class}[ObjectId: #{object_id}]}"
+    end
   end
 end

data/sub/eac_config/lib/eac_config/node_entry.rb

@@ -18,5 +18,10 @@ module EacConfig
     def secret_value
       value
     end
+
+    # @return [String]
+    def to_s
+      "#{self.class}[Node: #{node}, Path: #{path}]"
+    end
   end
 end

data/sub/eac_config/lib/eac_config/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacConfig
-  VERSION = '0.10.0'
+  VERSION = '0.11.1'
 end

data/sub/eac_config/lib/eac_config/yaml_file_node.rb

@@ -31,6 +31,10 @@ module EacConfig
       ::Addressable::URI.parse("file://#{path.expand_path}")
     end
 
+    def to_s
+      "#{self.class}[#{path}]"
+    end
+
     private
 
     def data_uncached

data/sub/eac_config/spec/lib/eac_config/envvars_node_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'eac_config/envvars_node'
+require 'eac_ruby_utils/ruby'
 
 RSpec.describe ::EacConfig::EnvvarsNode do
   let(:instance) { described_class.new }
@@ -18,6 +19,16 @@ RSpec.describe ::EacConfig::EnvvarsNode do
     it { expect(entry.value).to eq('AAA') }
     it { expect(entry.found_node).to eq(instance) }
     it { expect(entry).to be_found }
+
+    context 'with a clean ruby environment' do
+      let(:entry_value) do
+        ::EacRubyUtils::Ruby.on_clean_environment do
+          entry.value
+        end
+      end
+
+      it { expect(entry_value).to eq('AAA') }
+    end
   end
 
   context 'with blank entry' do

data/sub/eac_ruby_utils/eac_ruby_utils.gemspec

@@ -16,9 +16,9 @@ Gem::Specification.new do |s|
   s.files = Dir['{lib}/**/*', 'MIT-LICENSE', 'README.rdoc']
 
   s.add_dependency 'activesupport', '>= 4', '< 7'
-  s.add_dependency 'addressable', '~> 2.6'
+  s.add_dependency 'addressable', '~> 2.8'
   s.add_dependency 'bundler'
-  s.add_dependency 'filesize'
+  s.add_dependency 'filesize', '~> 0.2'
   s.add_dependency 'net-ssh', '~> 4.2'
   s.add_development_dependency 'eac_ruby_gem_support', '~> 0.5.1'
 end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/common_constructor/class_accessors.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/common_constructor/instance_initialize'
+require 'eac_ruby_utils/common_constructor/super_args'
+
+module EacRubyUtils
+  class CommonConstructor
+    class ClassAccessors
+      attr_reader :common_constructor, :klass
+
+      def initialize(common_constructor, klass)
+        @common_constructor = common_constructor
+        @klass = klass
+      end
+
+      def args
+        common_constructor.all_args
+      end
+
+      def perform
+        setup_class_attr_readers
+        setup_class_attr_writers
+      end
+
+      def setup_class_attr_readers
+        klass.send(:attr_reader, *args)
+        klass.send(:public, *args) if args.any?
+      end
+
+      def setup_class_attr_writers
+        klass.send(:attr_writer, *args)
+        klass.send(:private, *args.map { |a| "#{a}=" }) if args.any?
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/common_constructor/class_initialize.rb

@@ -13,17 +13,27 @@ module EacRubyUtils
         @klass = klass
       end
 
-      def run
+      def define_initialize_callbacks
+        klass.include(::ActiveSupport::Callbacks)
+        klass.define_callbacks :initialize
+      end
+
+      def define_initialize_method
         class_initialize = self
-        klass.send(:define_method, :initialize) do |*args|
+        klass.send(:define_method, :initialize) do |*args, &block|
           ::EacRubyUtils::CommonConstructor::InstanceInitialize.new(
-            class_initialize.common_constructor, args, self
-          ).run
+            class_initialize.common_constructor, args, self, block
+          ).perform
           super(*::EacRubyUtils::CommonConstructor::SuperArgs.new(
             class_initialize, args, self
           ).result)
         end
       end
+
+      def perform
+        define_initialize_callbacks
+        define_initialize_method
+      end
     end
   end
 end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/common_constructor/instance_initialize.rb

@@ -3,18 +3,20 @@
 module EacRubyUtils
   class CommonConstructor
     class InstanceInitialize
-      attr_reader :common_constructor, :args, :object
+      attr_reader :common_constructor, :args, :object, :block
 
-      def initialize(common_constructor, args, object)
+      def initialize(common_constructor, args, object, block)
         @common_constructor = common_constructor
         @args = args
         @object = object
+        @block = block
       end
 
-      def run
+      def perform
         validate_args_count
         object.run_callbacks :initialize do
           object_attributes_set
+          object_block_set
           object_after_callback
         end
       end
@@ -36,12 +38,21 @@ module EacRubyUtils
         object.instance_eval(&common_constructor.after_set_block)
       end
 
+      def object_attribute_set(attr_name, attr_value)
+        object.send("#{attr_name}=", attr_value)
+      end
+
       def object_attributes_set
         common_constructor.args.each do |arg_name|
-          object.send("#{arg_name}=", arg_value(arg_name))
+          object_attribute_set(arg_name, arg_value(arg_name))
         end
       end
 
+      def object_block_set
+        block_arg = common_constructor.block_arg
+        object_attribute_set(block_arg, block) if block_arg
+      end
+
       def validate_args_count
         return if common_constructor.args_count.include?(args.count)
 

data/sub/eac_ruby_utils/lib/eac_ruby_utils/common_constructor.rb

@@ -2,12 +2,13 @@
 
 require 'active_support/callbacks'
 require 'eac_ruby_utils/arguments_consumer'
+require 'eac_ruby_utils/common_constructor/class_accessors'
 require 'eac_ruby_utils/common_constructor/class_initialize'
 require 'ostruct'
 
 module EacRubyUtils
   class CommonConstructor
-    attr_reader :args, :options, :after_set_block
+    attr_reader :all_args, :options, :after_set_block
 
     class << self
       def parse_args_options(args)
@@ -37,11 +38,15 @@ module EacRubyUtils
 
     def initialize(*args, &after_set_block)
       args_processed = self.class.parse_args_options(args)
-      @args = args_processed.args
+      @all_args = args_processed.args
       @options = args_processed.options
       @after_set_block = after_set_block
     end
 
+    def args
+      block_arg? ? all_args[0..-2] : all_args
+    end
+
     def args_count
       (args_count_min..args_count_max)
     end
@@ -54,32 +59,32 @@ module EacRubyUtils
       args.count
     end
 
+    def block_arg
+      block_arg? ? all_args.last : nil
+    end
+
+    def block_arg?
+      options[:block_arg] || false
+    end
+
     def default_values
       options[:default] || []
     end
 
     def setup_class(klass)
-      setup_class_attr_readers(klass)
-      setup_class_attr_writers(klass)
+      setup_class_accessors(klass)
+
       setup_class_initialize(klass)
 
       klass
     end
 
-    def setup_class_attr_readers(klass)
-      klass.send(:attr_reader, *args)
-      klass.send(:public, *args) if args.any?
-    end
-
-    def setup_class_attr_writers(klass)
-      klass.send(:attr_writer, *args)
-      klass.send(:private, *args.map { |a| "#{a}=" }) if args.any?
+    def setup_class_accessors(klass)
+      ::EacRubyUtils::CommonConstructor::ClassAccessors.new(self, klass).perform
     end
 
     def setup_class_initialize(klass)
-      klass.include(::ActiveSupport::Callbacks)
-      klass.define_callbacks :initialize
-      ::EacRubyUtils::CommonConstructor::ClassInitialize.new(self, klass).run
+      ::EacRubyUtils::CommonConstructor::ClassInitialize.new(self, klass).perform
     end
 
     def super_args

data/sub/eac_ruby_utils/lib/eac_ruby_utils/ruby/on_clean_environment.rb

@@ -1,37 +1,70 @@
 # frozen_string_literal: true
 
 require 'bundler'
+require 'eac_ruby_utils/ruby/on_replace_objects'
 
 module EacRubyUtils
   module Ruby
     class << self
       # Executes a block in an environment when the variables BUNDLE* and RUBY* are removed.
-      def on_clean_environment
-        bundler_with_unbundled_env do
-          on_clean_envvars('BUNDLE', 'RUBY') { yield }
-        end
+      def on_clean_environment(&block)
+        OnCleanEnvironment.new(&block).perform
       end
 
-      private
+      class OnCleanEnvironment
+        ENVVARS_PREFIXES_TO_CLEAN = %w[BUNDLE RUBY].freeze
+
+        attr_reader :block, :original_env
 
-      def bundler_with_unbundled_env(&block)
-        if ::Bundler.respond_to?(:with_unbundled_env)
-          ::Bundler.with_unbundled_env(&block)
-        else
-          ::Bundler.with_clean_env(&block)
+        def initialize(&block)
+          @block = block
+          @original_env = ::ENV.to_h
         end
-      end
 
-      def on_clean_envvars(*start_with_vars)
-        old_values = envvars_starting_with(start_with_vars)
-        old_values.each_key { |k| ENV.delete(k) }
-        yield
-      ensure
-        old_values&.each { |k, v| ENV[k] = v }
-      end
+        # @return [Array<String>]
+        def envvars_prefixes_to_clean
+          ENVVARS_PREFIXES_TO_CLEAN
+        end
 
-      def envvars_starting_with(start_with_vars)
-        ENV.select { |k, _v| start_with_vars.any? { |var| k.start_with?(var) } }
+        def perform
+          bundler_with_unbundled_env do
+            on_clean_envvars
+          end
+        end
+
+        private
+
+        def bundler_with_unbundled_env(&block)
+          with_bundler_modified do
+            ::Bundler.send(bundler_with_env_method_name, &block)
+          end
+        end
+
+        def bundler_with_env_method_name
+          if ::Bundler.respond_to?(:with_unbundled_env)
+            :with_unbundled_env
+          else
+            :with_clean_env
+          end
+        end
+
+        def clean_env
+          r = original_env.dup
+          r.delete_if { |k, _| envvars_prefixes_to_clean.any? { |prefix| k.start_with?(prefix) } }
+          r
+        end
+
+        def on_clean_envvars
+          ::Bundler.send('with_env', clean_env) { block.call }
+        end
+
+        def with_bundler_modified(&block)
+          cloned_env = original_env.dup
+          ::EacRubyUtils::Ruby.on_replace_objects do |replacer|
+            replacer.replace_self_method(::Bundler, :original_env) { cloned_env }
+            block.call
+          end
+        end
       end
     end
   end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/ruby/on_replace_objects/replace_instance_method.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+require 'eac_ruby_utils/ruby/on_replace_objects/replace_instance_method'
+
+module EacRubyUtils
+  module Ruby
+    class OnReplaceObjects
+      class ReplaceInstanceMethod
+        attr_reader :a_module, :method_new_block, :original_method
+
+        def initialize(a_module, method_name, &method_new_block)
+          @a_module = a_module
+          @original_method = a_module.instance_method(method_name)
+          @method_new_block = method_new_block
+        end
+
+        def apply
+          a_module.define_method(method_name, &method_new_block)
+
+          self
+        end
+
+        def method_name
+          original_method.name
+        end
+
+        def restore
+          a_module.define_method(method_name, original_method)
+
+          self
+        end
+      end
+    end
+  end
+end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/ruby/on_replace_objects.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'active_support/inflector'
+require 'eac_ruby_utils/ruby/on_replace_objects/replace_instance_method'
+
+module EacRubyUtils
+  module Ruby
+    class << self
+      def on_replace_objects
+        replacer = OnReplaceObjects.new
+        replacer.on_replacement do
+          yield(replacer)
+        end
+      end
+    end
+
+    class OnReplaceObjects
+      def on_replacement(&block)
+        clear_replacements
+        block.call(self)
+      ensure
+        restore_replacements
+      end
+
+      def replace_instance_method(a_module, method_name, &block)
+        add_replacement(__method__, a_module, method_name, &block)
+      end
+
+      def replace_self_method(object, method_name, &block)
+        add_replacement(:replace_instance_method, object.singleton_class, method_name, &block)
+      end
+
+      private
+
+      def add_replacement(method_name, *args, &block)
+        @replacements << replacement_class(method_name).new(*args, &block).apply
+      end
+
+      def replacement_class(method_name)
+        self.class.const_get(::ActiveSupport::Inflector.camelize(method_name))
+      end
+
+      def clear_replacements
+        @replacements = []
+      end
+
+      def restore_replacements
+        @replacements.reverse.each(&:restore)
+      end
+    end
+  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.100.0'
+  VERSION = '0.102.0'
 end

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

@@ -93,6 +93,32 @@ RSpec.describe ::EacRubyUtils::CommonConstructor do
     end
   end
 
+  context 'with block argument' do
+    let(:instance) do
+      described_class.new(:first, :second, :last, block_arg: true, default: ['second'])
+    end
+
+    let(:block) do
+      ::Proc.new { first + second }
+    end
+
+    let(:a_class) do
+      ::Class.new do
+        def result
+          last.run
+        end
+      end
+    end
+
+    let(:a_class_instance) { a_class.new('first') { 'last' } }
+
+    it { expect(a_class_instance.last).to be_a(::Proc) }
+    it { expect(a_class_instance.last.call).to eq('last') }
+
+    it { expect(a_class_instance.first).to eq('first') }
+    it { expect(a_class_instance.second).to eq('second') }
+  end
+
   context 'with class hierarchy mixed with and without common_constructor' do
     let(:klass_0) do
       described_class.new(:a_param).setup_class(::Class.new)

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/{ruby_spec.rb → ruby/on_clean_environment_spec.rb}

@@ -6,9 +6,12 @@ RSpec.describe ::EacRubyUtils::Ruby do
   describe '#on_clean_environment' do
     let(:envvar_name) { 'BUNDLE_NOT_EXISTENT_ENV_VAR' }
     let(:envvar_value) { 'any value' }
+    let(:noruby_envvar_name) { 'ANY_ENVIRONMENT_VARIABLE' }
+    let(:noruby_envvar_value) { 'another any value' }
 
     before do
       ENV[envvar_name] = envvar_value
+      ENV[noruby_envvar_name] = noruby_envvar_value
     end
 
     it do # rubocop:disable RSpec/MultipleExpectations
@@ -18,5 +21,13 @@ RSpec.describe ::EacRubyUtils::Ruby do
       end
       expect(ENV[envvar_name]).to eq(envvar_value)
     end
+
+    it do # rubocop:disable RSpec/MultipleExpectations
+      expect(ENV[noruby_envvar_name]).to eq(noruby_envvar_value)
+      described_class.on_clean_environment do
+        expect(ENV[noruby_envvar_name]).to eq(noruby_envvar_value)
+      end
+      expect(ENV[noruby_envvar_name]).to eq(noruby_envvar_value)
+    end
   end
 end

data/sub/eac_ruby_utils/spec/lib/eac_ruby_utils/ruby/on_replace_objects_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/ruby'
+
+RSpec.describe ::EacRubyUtils::Ruby do
+  describe '#on_replace_objects' do
+    let(:stub_class) do
+      ::Class.new do
+        def self.my_class_method
+          'Original'
+        end
+
+        def my_instance_method
+          'Original'
+        end
+      end
+    end
+
+    let(:stub_instance) { stub_class.new }
+
+    let(:replace_block) do
+      ::Proc.new { 'Replaced' }
+    end
+
+    describe '#my_instance_method' do
+      let(:before) { stub_instance.my_instance_method }
+      let(:inside) do
+        described_class.on_replace_objects do |replacer|
+          replacer.replace_instance_method(stub_class, :my_instance_method, &replace_block)
+          stub_instance.my_instance_method
+        end
+      end
+      let(:after) { stub_instance.my_instance_method }
+
+      before do
+        before
+        inside
+        after
+      end
+
+      it { expect(before).to eq('Original') }
+      it { expect(inside).to eq('Replaced') }
+      it { expect(after).to eq('Original') }
+    end
+
+    describe '#replace_self_method' do
+      let(:before) { stub_class.my_class_method }
+      let(:inside) do
+        described_class.on_replace_objects do |replacer|
+          replacer.replace_self_method(stub_class, :my_class_method, &replace_block)
+          stub_class.my_class_method
+        end
+      end
+      let(:after) { stub_class.my_class_method }
+
+      before do
+        before
+        inside
+        after
+      end
+
+      it { expect(before).to eq('Original') }
+      it { expect(inside).to eq('Replaced') }
+      it { expect(after).to eq('Original') }
+    end
+  end
+end