eac_tools 0.120.0 → 0.122.0

data/sub/eac_docker/lib/eac_docker/container/identifiers.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module EacDocker
+  class Container
+    module Identifiers
+      common_concern do
+        immutable_accessor :name, type: :common
+      end
+
+      attr_reader :id
+
+      # Value that identifies the container to Docker commands: {#id}, if present, or {#name}.
+      #
+      # @return [String]
+      def identifier
+        id.presence || name.presence || raise('Neither `id` or `name` is present ' \
+                                              '- need at least one of them')
+      end
+
+      protected
+
+      attr_writer :id
+    end
+  end
+end

data/sub/eac_docker/lib/eac_docker/container/run_command.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module EacDocker
+  class Container
+    class RunCommand
+      acts_as_instance_method
+      common_constructor :container, :extra_args, default: [[]]
+      delegate :capabilities, :command_args, :envs, :image, :interactive?, :name, :temporary?,
+               :tty?, :volumes, to: :container
+
+      # @return [EacRubyUtils::Envs::Command]
+      def result
+        ::EacDocker::Executables.docker.command('run', *all_args)
+      end
+
+      # @return [Array<String>]
+      def all_args
+        %w[boolean capabilities envs name volumes]
+          .inject([]) { |a, e| a + send("#{e}_args") } +
+          extra_args + [image.provide.id] + command_args
+      end
+
+      # @return [Array<String>]
+      def boolean_args
+        r = []
+        r << '--interactive' if interactive?
+        r << '--tty' if tty?
+        r << '--rm' if temporary?
+        r
+      end
+
+      # @return [Array<String>]
+      def capabilities_args
+        capabilities.flat_map { |capability| ['--cap-add', capability] }
+      end
+
+      # @return [Array<String>]
+      def envs_args
+        envs.flat_map { |name, value| ['--env', "#{name}=#{value}"] }
+      end
+
+      # @return [Array<String>]
+      def name_args
+        name.if_present([]) { |v| ['--name', v] }
+      end
+
+      # @return [Array<String>]
+      def volumes_args
+        volumes.flat_map { |volume| ['--volume', volume] }
+      end
+    end
+  end
+end

data/sub/eac_docker/lib/eac_docker/container/start_command.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module EacDocker
+  class Container
+    # Start an already existing container identified by {#id}, if present, or {#name}.
+    class StartCommand
+      acts_as_instance_method
+      common_constructor :container
+      delegate :identifier, :interactive?, :tty?, to: :container
+
+      # @return [EacRubyUtils::Envs::Command]
+      def result
+        ::EacDocker::Executables.docker.command('start', *start_args)
+      end
+
+      # @return [Array<String>]
+      def start_args
+        r = []
+        r << '--attach' if interactive? || tty?
+        r << '--interactive' if interactive?
+        r << identifier
+        r
+      end
+    end
+  end
+end

data/sub/eac_docker/lib/eac_docker/container.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module EacDocker
+  class Container
+    enable_immutable
+    immutable_accessor :interactive, :temporary, :tty, type: :boolean
+    immutable_accessor :env, type: :hash
+    immutable_accessor :capability, :command_arg, :volume, type: :array
+
+    common_constructor :image
+
+    def immutable_constructor_args
+      [image]
+    end
+
+    alias immutable_volume volume
+
+    def hostname
+      ::EacDocker::Executables.docker.command(
+        'inspect', '--format={{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}',
+        id
+      ).execute!.strip
+    end
+
+    # @return [String]
+    def logs
+      ::EacDocker::Executables.docker.command('logs', id).execute!
+    end
+
+    def on_detached
+      self.id = run_command(%w[--detach]).execute!.strip
+      begin
+        yield(self)
+      ensure
+        stop
+      end
+    end
+
+    def volume(left_part, right_part = nil)
+      immutable_volume(right_part.if_present(left_part) { |v| "#{left_part}:#{v}" })
+    end
+
+    # Force removal of the container identified by {#id}, if present, or {#name}.
+    #
+    # @return [String] output of the "docker rm" command.
+    def remove_command
+      ::EacDocker::Executables.docker.command('rm', '--force', identifier)
+    end
+
+    def stop
+      ::EacDocker::Executables.docker.command('stop', id).execute!
+    end
+
+    require_sub __FILE__, require_mode: :kernel, include_modules: true
+  end
+end

data/sub/eac_docker/lib/eac_docker/debug.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module EacDocker
+  module Debug
+    class << self
+      ENABLE_ENVVAR = 'EAC_DOCKER_DEBUG'
+
+      def enabled?
+        ::EacRubyUtils::Boolean.parse(ENV.fetch(ENABLE_ENVVAR, nil))
+      end
+    end
+  end
+end

data/sub/eac_docker/lib/eac_docker/executables.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module EacDocker
+  module Executables
+    class << self
+      def env
+        ::EacRubyUtils::Envs.local
+      end
+
+      def docker
+        @docker ||= env.executable('docker', '--version')
+      end
+    end
+  end
+end

data/sub/eac_docker/lib/eac_docker/images/base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module EacDocker
+  module Images
+    class Base
+      def container
+        ::EacDocker::Container.new(self)
+      end
+    end
+  end
+end

data/sub/eac_docker/lib/eac_docker/images/coded.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module EacDocker
+  module Images
+    class Coded < ::EacDocker::Images::Base
+      enable_simple_cache
+      enable_immutable
+      immutable_accessor :tag
+      common_constructor :path do
+        self.path = path.to_pathname
+      end
+
+      def immutable_constructor_args
+        [path]
+      end
+
+      def provide
+        id
+        self
+      end
+
+      private
+
+      def id_uncached
+        if ::EacDocker::Debug.enabled?
+          ::EacDocker::Executables.docker.command(*build_args.excluding('--quiet')).system!
+        end
+        ::EacDocker::Executables.docker.command(*build_args).execute!.strip
+          .then { |digest| tag.presence || digest }
+      end
+
+      def build_args
+        args = %w[build --quiet]
+        args += ['--tag', tag] if tag.present?
+        args + [path.to_path]
+      end
+    end
+  end
+end

data/sub/eac_docker/lib/eac_docker/images/named.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module EacDocker
+  module Images
+    class Named < ::EacDocker::Images::Base
+      common_constructor :source_tag
+
+      # @return [Boolean]
+      def exist?
+        ::EacDocker::Executables.docker.command('image', 'inspect', source_tag).execute
+          .fetch(:exit_code).zero?
+      end
+
+      def id
+        source_tag
+      end
+
+      def provide
+        provide_command.execute! unless exist?
+        self
+      end
+
+      def provide_command
+        ::EacDocker::Executables.docker.command(*docker_provide_args)
+      end
+
+      def docker_provide_args
+        ['pull', source_tag]
+      end
+    end
+  end
+end

data/sub/eac_docker/lib/eac_docker/images/templatized.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module EacDocker
+  module Images
+    class Templatized < ::EacDocker::Images::Base
+      enable_immutable
+      immutable_accessor :tag
+      attr_reader :provide_dir
+
+      def id
+        tag
+      end
+
+      def provide
+        ::EacRubyUtils::Fs::Temp.on_directory do |provide_dir|
+          self.provide_dir = provide_dir
+          write_in_provide_dir
+          coded_image(provide_dir).tag(tag).provide
+        ensure
+          self.provide_dir = nil
+        end
+      end
+
+      def coded_image(provide_dir)
+        ::EacDocker::Images::Coded.new(provide_dir)
+      end
+
+      protected
+
+      def variables_source
+        self
+      end
+
+      def write_in_provide_dir
+        eac_template.apply(variables_source, provide_dir)
+      end
+
+      private
+
+      attr_writer :provide_dir
+    end
+  end
+end

data/sub/eac_docker/lib/eac_docker/registry.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module EacDocker
+  class Registry
+    common_constructor :name
+
+    def to_s
+      name
+    end
+
+    def sub(suffix)
+      self.class.new("#{name}#{suffix}")
+    end
+  end
+end

data/sub/eac_docker/lib/eac_docker/rspec/setup.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module EacDocker
+  module Rspec
+    module Setup
+      def self.extended(obj)
+        obj.setup_conditional_docker_executable
+      end
+
+      def setup_conditional_docker_executable
+        conditional(:docker) { ::EacDocker::Executables.docker.validate }
+      end
+    end
+  end
+end

data/sub/eac_docker/lib/eac_docker/rspec/stub_image.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module EacDocker
+  module Rspec
+    class StubImage
+      include ::ActiveSupport::Callbacks
+
+      define_callbacks :on_container
+      common_constructor :image
+
+      def build_container
+        image.provide.container.temporary(true)
+      end
+
+      def container
+        raise 'internal container is blank' if internal_container.blank?
+
+        internal_container
+      end
+
+      def on_container(&)
+        raise 'A container was already created' if internal_container.present?
+
+        build_container.on_detached do |container|
+          self.internal_container = container
+          begin
+            run_callbacks(:on_container, &)
+          ensure
+            self.internal_container = nil
+          end
+        end
+      end
+
+      private
+
+      attr_accessor :internal_container
+    end
+  end
+end

data/sub/eac_docker/lib/eac_docker/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module EacDocker
+  VERSION = '0.9.0'
+end

data/sub/eac_docker/lib/eac_docker.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_base1'
+EacRubyBase1::RootModuleSetup.perform __FILE__ do
+  require 'eac_templates'
+end

data/sub/eac_docker/spec/lib/eac_docker/container_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+RSpec.describe(EacDocker::Container, :docker) do
+  let(:image) { EacDocker::Images::Named.new('alpine') }
+  let(:instance) { described_class.new(image) }
+
+  it do
+    expect(instance.id).to be_blank
+  end
+
+  describe '#run_command' do
+    it do
+      expect(instance.command_arg('whoami').run_command.execute!.strip).to eq('root')
+    end
+  end
+
+  describe '#on_detached' do
+    it do
+      instance.on_detached do
+        expect(instance.id).to be_present
+      end
+    end
+  end
+end

data/sub/eac_docker/spec/lib/eac_docker/executables_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe(EacDocker::Executables, :docker) do
+  it 'output version' do
+    expect(described_class.docker.command('--version').execute!).to be_present
+  end
+end

data/sub/eac_docker/spec/lib/eac_docker/images/coded_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+RSpec.describe(EacDocker::Images::Coded, :docker) do
+  let(:fixtures_dir) { Pathname.new('coded_spec_files').expand_path(__dir__) }
+  let(:instance) { described_class.new(fixtures_dir / 'image1') }
+
+  describe '#provide' do
+    it { expect { instance.provide }.not_to raise_error }
+  end
+end

data/sub/eac_docker/spec/lib/eac_docker/images/coded_spec_files/image1/Dockerfile

@@ -0,0 +1 @@
+from ubuntu:bionic

data/sub/eac_docker/spec/lib/eac_docker/images/templatized_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+RSpec.describe(EacDocker::Images::Templatized, :docker) do
+  let(:fixtures_dir) { Pathname.new('templatized_spec_files').expand_path(__dir__) }
+  let(:instance) { StubDockerImage.new }
+
+  before do
+    EacTemplates::Sources::Set.default.included_paths << fixtures_dir
+    stub_const('StubDockerImage', Class.new(described_class))
+  end
+
+  describe '#provide' do
+    it { expect { instance.provide }.not_to raise_error }
+  end
+end

data/sub/eac_docker/spec/lib/eac_docker/images/templatized_spec_files/stub_docker_image/Dockerfile

@@ -0,0 +1 @@
+from ubuntu:bionic

data/sub/{avm-eac_ruby_base1/spec/lib/avm/eac_ruby_base1/source_generators/base_spec_files/mygem → eac_docker}/spec/spec_helper.rb

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

data/sub/eac_ruby_utils/lib/eac_ruby_utils/acts_as_instance_method.rb

@@ -2,12 +2,19 @@
 
 require 'active_support/core_ext/module/introspection'
 require 'eac_ruby_utils/patches/class/common_constructor'
+require 'eac_ruby_utils/patches/module/listable'
 require 'eac_ruby_utils/patches/module/module_parent'
 require 'eac_ruby_utils/patches/string/inflector'
 
 module EacRubyUtils
   class ActsAsInstanceMethod
-    common_constructor :method_class
+    enable_listable
+    lists.add_symbol :option, :name_mark
+    lists.add_symbol :name_mark, '': :none, '!': :exclamation, '?': :interrogation
+
+    common_constructor :method_class, :options, default: [{}] do
+      self.options = ::EacRubyUtils::ActsAsInstanceMethod.lists.option.hash_keys_validate!(options)
+    end
 
     # @param sender_module [Module, nil]
     # @return [self]
@@ -23,7 +30,12 @@ module EacRubyUtils
 
     # @return [String]
     def method_name
-      method_class.name.demodulize.underscore.variableize
+      "#{method_class.name.demodulize.underscore.variableize}#{method_name_mark}"
+    end
+
+    # @return [Symbol]
+    def method_name_mark
+      options[OPTION_NAME_MARK] || NAME_MARK_NONE
     end
 
     # @return [Module]

data/sub/eac_ruby_utils/lib/eac_ruby_utils/envs/base_command/execution.rb

@@ -10,6 +10,12 @@ module EacRubyUtils
   module Envs
     module BaseCommand
       module Execution
+        common_concern do
+          include ActiveSupport::Callbacks
+
+          define_callbacks :any_execution, :execute, :spawn, :system
+        end
+
         def execute!(options = {})
           options[:exit_outputs] = status_results.merge(options[:exit_outputs].presence || {})
           er = ::EacRubyUtils::Envs::ExecutionResult.new(execute(options), options)
@@ -23,7 +29,9 @@ module EacRubyUtils
           c = command(options)
           debug_print("BEFORE: #{c}")
           t1 = Time.now
-          r = ::EacRubyUtils::Envs::Process.new(c).to_h
+          r = run_callbacks :any_execution, :execute do
+            ::EacRubyUtils::Envs::Process.new(c).to_h
+          end
           i = Time.now - t1
           debug_print("AFTER [#{i}]: #{c}")
           r
@@ -32,7 +40,9 @@ module EacRubyUtils
         def spawn(options = {})
           c = command(options)
           debug_print("SPAWN: #{c}")
-          ::EacRubyUtils::Envs::Spawn.new(c)
+          run_callbacks :any_execution, :spawn do
+            ::EacRubyUtils::Envs::Spawn.new(c)
+          end
         end
 
         def system!(options = {})
@@ -44,7 +54,7 @@ module EacRubyUtils
         def system(options = {})
           c = command(options)
           debug_print(c)
-          Kernel.system(c)
+          run_callbacks(:any_execution, :system) { Kernel.system(c) }
         end
       end
     end

data/sub/eac_ruby_utils/lib/eac_ruby_utils/method_class.rb

@@ -11,8 +11,10 @@ module EacRubyUtils
     end
 
     class Setup < ::EacRubyUtils::ActsAsInstanceMethod
-      common_constructor :method_class, :static_method, default: [false],
-                                                        super_args: -> { [method_class] } do
+      common_constructor :method_class, :static_method, :options, default: [false, {}],
+                                                                  super_args: lambda {
+                                                                    [method_class, options]
+                                                                  } do
         perform
       end
 

data/sub/eac_ruby_utils/lib/eac_ruby_utils/patch_module.rb

@@ -3,15 +3,15 @@
 require 'eac_ruby_utils/patches/module/common_concern'
 
 module EacRubyUtils
-  module PatchModule
-    common_concern
-
-    class_methods do
-      delegate :patch_module, to: :'::EacRubyUtils::PatchModule'
+  class << self
+    def patch_module(*)
+      ::EacRubyUtils::PatchModule.perform(*)
     end
+  end
 
+  module PatchModule
     class << self
-      def patch_module(target, patch)
+      def perform(target, patch)
         return if target.include?(patch)
 
         target.send(:include, patch)

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

@@ -3,8 +3,9 @@
 require 'eac_ruby_utils/acts_as_instance_method'
 
 class Module
+  # @param options [Hash]
   # @return [EacRubyUtils::ActsAsInstanceMethod]
-  def acts_as_instance_method
-    ::EacRubyUtils::ActsAsInstanceMethod.new(self).setup
+  def acts_as_instance_method(**options)
+    ::EacRubyUtils::ActsAsInstanceMethod.new(self, options).setup
   end
 end

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

@@ -4,6 +4,6 @@ require 'eac_ruby_utils/patch_module'
 
 class Module
   def patch_self(patch_module)
-    ::EacRubyUtils::PatchModule.patch_module(self, patch_module)
+    ::EacRubyUtils::PatchModule.perform(self, patch_module)
   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.132.0'
+  VERSION = '0.134.0'
 end

data/sub/eac_ruby_utils/lib/eac_ruby_utils.rb

@@ -9,7 +9,6 @@ EacRubyUtils::RootModuleSetup.perform __FILE__ do
 end
 
 module EacRubyUtils
-  include ::EacRubyUtils::PatchModule
 end
 
 require 'eac_ruby_utils/core_ext'