eac_tools 0.64.0 → 0.65.1

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'avm/instances/runner'
+require 'eac_cli/core_ext'
+
+module Avm
+  module Tools
+    class Runner
+      class Instance < ::Avm::Instances::Runner
+        class Data
+          class Unit
+            class Load
+              runner_with :help do
+                pos_arg :dump_path
+              end
+
+              def run
+                runner_context.call(:data_unit).load(dump_path)
+              end
+
+              # @return [Pathname]
+              def dump_path
+                parsed.dump_path.to_pathname
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

data/sub/eac_envs-http/lib/eac_envs/http/rspec/echo_server/request_processor.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'eac_envs/http/request'
+require 'eac_ruby_utils/core_ext'
+require 'webrick'
+
+module EacEnvs
+  module Http
+    module Rspec
+      class EchoServer
+        class RequestProcessor
+          REQUEST_TO_DATA = {
+            ssl: :ssl?,
+            method: :request_method,
+            uri: :unparsed_uri,
+            body: :body
+          }.freeze
+
+          common_constructor :request, :response
+
+          def perform
+            response.body = response_body
+            response.header['Content-type'] = 'application/json'
+            response.status = 200
+          end
+
+          def request_data
+            REQUEST_TO_DATA.map { |k, v| [k, request.send(v)] }.to_h.merge(headers: request_headers)
+          end
+
+          def request_headers
+            request.header.map { |k, v| [k, v.first] }.to_h
+          end
+
+          def response_body
+            ::JSON.generate(request_data)
+          end
+        end
+      end
+    end
+  end
+end

data/sub/eac_envs-http/lib/eac_envs/http/rspec/echo_server/webrick_servlet.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'eac_envs/http/request'
+require 'eac_envs/http/rspec/echo_server/request_processor'
+require 'eac_ruby_utils/core_ext'
+require 'webrick'
+
+module EacEnvs
+  module Http
+    module Rspec
+      class EchoServer
+        class WebrickServlet < WEBrick::HTTPServlet::AbstractServlet
+          ::EacEnvs::Http::Request.lists.verb.each_value do |verb|
+            define_method "do_#{verb.to_s.upcase}" do |request, response|
+              ::EacEnvs::Http::Rspec::EchoServer::RequestProcessor.new(request, response).perform
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/sub/eac_envs-http/lib/eac_envs/http/rspec/echo_server.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'addressable'
+require 'eac_ruby_utils/core_ext'
+require 'webrick'
+require 'webrick/https'
+
+module EacEnvs
+  module Http
+    module Rspec
+      class EchoServer
+        HOSTNAME = 'localhost'
+        SCHEMES = {
+          http: { Port: 8080 },
+          https: { Port: 8443, SSLEnable: true, SSLCertName: [['CN', HOSTNAME]] }
+        }.freeze
+
+        class << self
+          SCHEMES.each do |scheme, webrick_options|
+            # @return [::EacEnvs::Http::Rspec::EchoServer]
+            define_method scheme do
+              new(scheme, webrick_options)
+            end
+          end
+        end
+
+        common_constructor :scheme, :webrick_options
+
+        def on_active(&block)
+          servlet = webrick_servlet
+          ::Thread.abort_on_exception = true
+          servlet_thread = ::Thread.new { servlet.start }
+          begin
+            sleep 0.001 while servlet.status != :Running
+            block.call
+          ensure
+            servlet.shutdown
+            servlet_thread.join
+          end
+        end
+
+        def root_url
+          ::Addressable::URI.new(
+            scheme: scheme.to_s,
+            host: ::EacEnvs::Http::Rspec::EchoServer::HOSTNAME,
+            port: webrick_options.fetch(:Port)
+          )
+        end
+
+        private
+
+        # @return [EacEnvs::Http::Rspec::EchoServer::WebrickServlet]
+        def webrick_servlet
+          r = ::WEBrick::HTTPServer.new(webrick_options)
+          r.mount '/', ::EacEnvs::Http::Rspec::EchoServer::WebrickServlet
+          r
+        end
+
+        require_sub __FILE__
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacEnvs
+  module Http
+    module Rspec
+      require_sub __FILE__
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module EacEnvs
+  module Http
+    VERSION = '0.3.2'
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module EacEnvs
+  module Http
+    require_sub __FILE__
+  end
+end