eac_tools 0.65.0 → 0.66.0

data/sub/avm-tools/lib/avm/tools/runner/instance/data/unit/clear.rb

@@ -10,11 +10,7 @@ module Avm
         class Data
           class Unit
             class Clear
-              runner_with :help
-
-              def run
-                runner_context.call(:data_unit).clear
-              end
+              runner_with :help, :instance_data_clear
             end
           end
         end

data/sub/avm-tools/lib/avm/tools/runner/instance/data/unit.rb

@@ -25,6 +25,11 @@ module Avm
               runner_context.call(:instance).data_package
             end
 
+            # @return [Avm::Instances::Data::Unit]
+            def data_owner
+              data_unit
+            end
+
             # @return [Avm::Instances::Data::Unit]
             def data_unit
               data_package.unit(parsed.identifier)

data/sub/avm-tools/lib/avm/tools/runner/instance/data.rb

@@ -13,6 +13,11 @@ module Avm
             desc 'Data utilities for EacRailsBase0 instances.'
             subcommands
           end
+
+          # @return [Avm::Instances::Data::Package]
+          def data_owner
+            instance.data_package
+          end
         end
       end
     end

data/sub/avm-tools/lib/avm/tools/runner/launcher.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'avm/tools/core_ext'
-require 'avm/projects/stereotypes'
 
 module Avm
   module Tools

data/sub/avm-tools/lib/avm/tools/runner/launcher_stereotypes/list.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'avm/launcher/stereotype'
-require 'avm/projects/stereotypes'
 require 'avm/tools/core_ext'
 
 module Avm

data/sub/avm-tools/lib/avm/tools/runner_with/instance_data_clear.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'eac_cli/core_ext'
+require 'eac_cli/runner'
+
+module Avm
+  module Tools
+    module RunnerWith
+      module InstanceDataClear
+        common_concern do
+          include ::EacCli::Runner
+        end
+
+        def run
+          data_owner.clear
+        end
+      end
+    end
+  end
+end

data/sub/avm-tools/lib/avm/tools/runner_with.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avm
+  module Tools
+    module RunnerWith
+      require_sub __FILE__, require_mode: :kernel
+    end
+  end
+end

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

@@ -2,6 +2,6 @@
 
 module Avm
   module Tools
-    VERSION = '0.147.0'
+    VERSION = '0.148.0'
   end
 end

data/sub/eac_cli/eac_cli.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'colorize', '~> 0.8', '>= 0.8.1'
   s.add_dependency 'eac_config', '~> 0.12'
-  s.add_dependency 'eac_ruby_utils', '~> 0.114'
+  s.add_dependency 'eac_ruby_utils', '~> 0.116'
 
   s.add_development_dependency 'eac_ruby_gem_support', '~> 0.5.1'
 end

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

@@ -18,19 +18,22 @@ 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.present?
+        return parent_call(method_name, *args) if parent_respond_to?(method_name)
 
         raise ::NameError, "No method \"#{method_name}\" found in #{runner} or in its ancestors"
       end
 
-      def respond_to_call?((method_name))
-        parent.respond_to?(:runner_context) && parent.runner_context.respond_to_call?(method_name)
-      end
+      # @param method_name [Symbol]
+      # @return [Boolean]
+      def parent_respond_to?(method_name)
+        parent.if_present(false) do |v|
+          next true if v.respond_to?(method_name)
 
-      protected
+          v.if_respond(:runner_context, false) { |w| w.parent_respond_to?(method_name) }
+        end
+      end
 
       def parent_call(method_name, *args)
-        return parent.context(method_name, *args) if parent.respond_to?(:context)
         return parent.runner_context.call(method_name, *args) if parent.respond_to?(:runner_context)
 
         raise "Parent #{parent} do not respond to .context or .runner_context (Runner: #{runner})"

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

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

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

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

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

@@ -19,6 +19,8 @@ RSpec.describe ::EacCli::RunnerWith::Subcommands do
       end
 
       delegate :root_var, to: :parsed
+
+      def method_in_parent_runner; end
     end
   end
 
@@ -31,7 +33,10 @@ RSpec.describe ::EacCli::RunnerWith::Subcommands do
         pos_arg :child_var
       end
 
-      def run; end
+      def run
+        runner_context.call(:method_in_parent_runner)
+        method_in_parent_runner
+      end
     end
   end
 
@@ -45,6 +50,10 @@ RSpec.describe ::EacCli::RunnerWith::Subcommands do
     it { expect(instance.parsed.subcommand_args).to eq(%w[--child-opt 456]) }
     it { expect(instance.subcommand_runner.parsed.child_opt).to eq(true) }
     it { expect(instance.subcommand_runner.parsed.child_var).to eq('456') }
+
+    it do
+      expect { instance.run_run }.not_to raise_error
+    end
   end
 
   context 'when subcommand is not supplied' do

data/sub/eac_envs-http/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gemspec
+
+local_gemfile = ::File.join(::File.dirname(__FILE__), 'Gemfile.local')
+eval_gemfile local_gemfile if ::File.exist?(local_gemfile)

data/sub/eac_envs-http/eac_envs-http.gemspec

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+
+require 'eac_envs/http/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'eac_envs-http'
+  s.version     = EacEnvs::Http::VERSION
+  s.authors     = ['Put here the authors']
+  s.summary     = 'Put here de description.'
+
+  s.files = Dir['{lib}/**/*']
+
+  s.add_dependency 'eac_fs', '~> 0.16'
+  s.add_dependency 'eac_ruby_utils', '~> 0.116'
+  s.add_dependency 'faraday', '~> 2.7', '>= 2.7.4'
+  s.add_dependency 'faraday-follow_redirects', '~> 0.3'
+  s.add_dependency 'faraday-gzip', '~> 0.1'
+  s.add_dependency 'faraday-multipart', '~> 1.0', '>= 1.0.4'
+  s.add_dependency 'faraday-retry', '~> 2.1'
+
+  s.add_development_dependency 'aranha-parsers', '~> 0.17'
+  s.add_development_dependency 'eac_ruby_gem_support', '~> 0.5', '>= 0.5.1'
+end

data/sub/eac_envs-http/lib/eac_envs/http/error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module EacEnvs
+  module Http
+    class Error < ::RuntimeError
+    end
+  end
+end

data/sub/eac_envs-http/lib/eac_envs/http/request/body_field.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'eac_envs/http/request/body_field_value'
+require 'eac_ruby_utils/core_ext'
+require 'faraday/multipart/file_part'
+
+module EacEnvs
+  module Http
+    class Request
+      class BodyField
+        class << self
+          # @return [Array<EacEnvs::Http::Request::BodyField>]
+          def list_from_enumerable(enum)
+            hash = {}
+            enum.each do |v|
+              hash[v[0]] ||= []
+              hash[v[0]] << v[1]
+            end
+            list_from_hash(hash)
+          end
+
+          # @return [Array<EacEnvs::Http::Request::BodyField>]
+          def list_from_hash(hash)
+            hash.map { |k, v| new(k, v) }
+          end
+        end
+
+        common_constructor :key, :values do
+          self.key = key.to_s
+          self.values = (values.is_a?(::Array) ? values.to_a : [values])
+                        .map { |v| ::EacEnvs::Http::Request::BodyFieldValue.new(v) }
+        end
+
+        # @return [String]
+        def hash_key
+          key
+        end
+
+        # @return [Array]
+        def hash_value
+          values.map(&:to_faraday)
+        end
+
+        # @return [Boolean]
+        def with_file?
+          values.any?(&:file?)
+        end
+      end
+    end
+  end
+end

data/sub/eac_envs-http/lib/eac_envs/http/request/body_field_value.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'eac_fs/file_info'
+require 'eac_ruby_utils/core_ext'
+require 'faraday'
+require 'faraday/multipart'
+
+module EacEnvs
+  module Http
+    class Request
+      class BodyFieldValue
+        common_constructor :value
+
+        def to_faraday
+          return value unless file?
+
+          ::Faraday::Multipart::FilePart.new(value, file_mime_type)
+        end
+
+        # @return [Boolean]
+        def file?
+          value.is_a?(::File)
+        end
+
+        # @return [String]
+        def file_mime_type
+          ::EacFs::FileInfo.new(value.path).mime_type
+        end
+      end
+    end
+  end
+end

data/sub/eac_envs-http/lib/eac_envs/http/request/body_fields.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'eac_envs/http/request/body_field'
+
+module EacEnvs
+  module Http
+    class Request
+      class BodyFields
+        common_constructor :source_body
+
+        # @return [Hash, nil]
+        def to_h
+          fields.if_present do |v|
+            v.each_with_object({}) { |e, a| a[e.hash_key] = e.hash_value }
+          end
+        end
+
+        # @return [Array<EacEnvs::Http::Request::BodyField>, nil]
+        def fields
+          source_body.if_present do |v|
+            next nil unless v.is_a?(::Enumerable)
+
+            if v.is_a?(::Hash)
+              ::EacEnvs::Http::Request::BodyField.list_from_hash(v)
+            else
+              ::EacEnvs::Http::Request::BodyField.list_from_enumerable(v)
+            end
+          end
+        end
+
+        # @return [Boolean]
+        def with_file?
+          fields.if_present(false) { |v| v.any?(&:with_file?) }
+        end
+      end
+    end
+  end
+end

data/sub/eac_envs-http/lib/eac_envs/http/request/faraday_connection.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'faraday'
+require 'faraday/follow_redirects'
+require 'faraday/gzip'
+require 'faraday/multipart'
+require 'faraday/retry'
+
+module EacEnvs
+  module Http
+    class Request
+      class FaradayConnection
+        enable_method_class
+        common_constructor :request
+
+        SETUPS = %i[multipart authorization follow_redirect gzip retry].freeze
+
+        # @return [Faraday::Connection]
+        def result
+          ::Faraday.default_connection_options[:headers] = {}
+          ::Faraday::Connection.new(connection_options) do |conn|
+            SETUPS.each { |setup| send("setup_#{setup}", conn) }
+          end
+        end
+
+        private
+
+        # @return [Boolean]
+        def body_with_file?
+          request.body_fields.with_file?
+        end
+
+        # @return [Hash]
+        def connection_options
+          {
+            request: { params_encoder: Faraday::FlatParamsEncoder },
+            ssl: { verify: request.ssl_verify? }
+          }
+        end
+
+        # @param conn [Faraday::Connection]
+        def setup_authorization(conn)
+          request.auth.if_present do |v|
+            conn.request :authorization, :basic, v.username, v.password
+          end
+        end
+
+        # @param conn [Faraday::Connection]
+        def setup_follow_redirect(conn)
+          conn.response :follow_redirects if request.follow_redirect?
+        end
+
+        # @param conn [Faraday::Connection]
+        def setup_gzip(conn)
+          conn.request :gzip
+        end
+
+        # @param conn [Faraday::Connection]
+        def setup_multipart(conn)
+          if body_with_file?
+            conn.request :multipart, flat_encode: true
+          else
+            conn.request :url_encoded
+          end
+        end
+
+        # @param conn [Faraday::Connection]
+        def setup_retry(conn)
+          conn.request :retry if request.retry?
+        end
+      end
+    end
+  end
+end

data/sub/eac_envs-http/lib/eac_envs/http/request.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'eac_envs/http/response'
+require 'eac_ruby_utils/core_ext'
+
+module EacEnvs
+  module Http
+    class Request
+      BOOLEAN_MODIFIERS = %w[follow_redirect retry ssl_verify].freeze
+      COMMON_MODIFIERS = %w[auth body_data response_body_data_proc url verb].freeze
+      HASH_MODIFIERS = %w[header].freeze
+      MODIFIERS = COMMON_MODIFIERS + BOOLEAN_MODIFIERS + HASH_MODIFIERS.map(&:pluralize)
+
+      enable_immutable
+      immutable_accessor(*BOOLEAN_MODIFIERS, type: :boolean)
+      immutable_accessor(*COMMON_MODIFIERS, type: :common)
+      immutable_accessor(*HASH_MODIFIERS, type: :hash)
+
+      enable_listable
+      lists.add_symbol :verb, :get, :delete, :options, :post, :put
+
+      def basic_auth(username, password)
+        auth(::Struct.new(:username, :password).new(username, password))
+      end
+
+      # @return [EacEnvs::Http::Request::BodyFields]
+      def body_fields
+        @body_fields ||= ::EacEnvs::Http::Request::BodyFields.new(body_data)
+      end
+
+      # @return [Faraday::Response]
+      def faraday_response
+        conn = faraday_connection
+        conn.send(sanitized_verb, url) do |req|
+          req.headers = conn.headers.merge(headers)
+          sanitized_body_data.if_present { |v| req.body = v }
+        end
+      end
+
+      def response
+        ::EacEnvs::Http::Response.new(self)
+      end
+
+      # @return [Symbol]
+      def sanitized_verb
+        verb.if_present(VERB_GET) { |v| self.class.lists.verb.value_validate!(v) }
+      end
+
+      private
+
+      def sanitized_body_data
+        body_fields.to_h || body_data
+      end
+
+      require_sub __FILE__, require_dependency: true
+    end
+  end
+end

data/sub/eac_envs-http/lib/eac_envs/http/response/body.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+require 'json'
+
+module EacEnvs
+  module Http
+    class Response < ::StandardError
+      module Body
+        delegate :response_body_data_proc, to: :request
+
+        def body_data
+          r = body_data_method_name.if_present(body_str) do |v|
+            respond_to?(v, true) ? send(v) : body_str
+          end
+          r = response_body_data_proc.call(r) if response_body_data_proc.present?
+          r
+        end
+
+        def body_data_or_raise
+          raise_unless_200
+
+          body_data
+        end
+
+        # @return [String]
+        def body_str
+          performed.body
+        end
+
+        def body_str_or_raise
+          raise_unless_200
+
+          body_str
+        end
+
+        private
+
+        def body_data_from_application_json
+          ::JSON.parse(body_str)
+        end
+
+        def body_data_from_application_xml
+          Hash.from_xml(body_str)
+        end
+
+        # @return [String]
+        def body_data_method_name
+          content_type.if_present do |v|
+            'body_data_from_' +
+              v.split(';').first.force_encoding(::Encoding::UTF_8).variableize
+          end
+        end
+      end
+    end
+  end
+end

data/sub/eac_envs-http/lib/eac_envs/http/response/headers.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacEnvs
+  module Http
+    class Response < ::StandardError
+      module Headers
+        COMMON_HEADERS = %w[Content-Type].freeze
+        HEADER_LINE_PARSER = /\A([^:]+):(.*)\z/.to_parser do |m|
+          [m[1].strip, m[2].strip]
+        end
+
+        def header(name)
+          hash_search(headers, name)
+        end
+
+        # @return [Hash<String, String>]
+        def headers
+          performed.headers.to_hash
+        end
+
+        COMMON_HEADERS.each do |header_key|
+          define_method header_key.underscore do
+            header(header_key)
+          end
+        end
+
+        private
+
+        def hash_search(hash, key)
+          key = key.to_s.downcase
+          hash.each do |k, v|
+            return v if k.to_s.downcase == key
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/sub/eac_envs-http/lib/eac_envs/http/response/links.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+module EacEnvs
+  module Http
+    class Response < ::StandardError
+      module Links
+        # https://www.w3.org/wiki/LinkHeader
+        LINKS_HEADER_NAME = 'Link'
+
+        # https://www.w3.org/wiki/LinkHeader
+        LINK_PARSER = /\A\<(.+)\>\s*;\s*rel\s*=\s*\"(.*)\"\z/.to_parser do |m|
+          [m[2], m[1]]
+        end
+
+        def link(rel)
+          hash_search(links, rel)
+        end
+
+        def links
+          header(LINKS_HEADER_NAME).if_present({}) do |v|
+            v.split(',').map { |w| LINK_PARSER.parse!(w.strip) }.to_h
+          end
+        end
+      end
+    end
+  end
+end

data/sub/eac_envs-http/lib/eac_envs/http/response/statuses.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacEnvs
+  module Http
+    class Response < ::StandardError
+      module Statuses
+        def raise_unless_200
+          return nil if status == 200
+
+          raise self
+        end
+
+        def status
+          performed.status.to_i
+        end
+      end
+    end
+  end
+end

data/sub/eac_envs-http/lib/eac_envs/http/response.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/hash/conversions'
+require 'eac_envs/http/error'
+require 'eac_ruby_utils/core_ext'
+require 'faraday'
+require 'json'
+
+module EacEnvs
+  module Http
+    class Response < ::StandardError
+      common_constructor :request
+      delegate :url, to: :request
+
+      def to_s
+        "URL: #{url}\nStatus: #{status}\nBody:\n\n#{body_str}"
+      end
+
+      private
+
+      def performed
+        @performed ||= request.faraday_response
+      rescue ::Faraday::Error
+        raise ::EacEnvs::Http::Error
+      end
+
+      require_sub __FILE__, include_modules: true
+    end
+  end
+end