eac_rest 0.7.1 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66c3020339ccd5df2e47dfd97c85114a10aaa67da61bacf21ca43ac834bbfc24
-  data.tar.gz: d2e34918c150896f372a686dc093905adf54b6f30db300622f07f6b187368af6
+  metadata.gz: 877e75934091f0d5f8dd8384c81c9cf426e9612302e3d4d2c6c0ebe152cfe055
+  data.tar.gz: 9dccadaff0e6213f94316cf029f2bc45983842d3403c3f43f48eaeadce52f5fd
 SHA512:
-  metadata.gz: 6fc42e19e74493f10ffd0e30473dd5b173c96317946b8950e021f996c211c8e2769d81785bdb4b60a471156f085fd0cc20c32747b78dc63b549e1bc964f2e818
-  data.tar.gz: fa104d01ea1de4bb202c40b5c602de8754300bd16cb358b9744e01575a77ce91f7206cfafb48f691850e84b61d31f379e096b6dedd50af38cd6aa2227efdeb00
+  metadata.gz: 4676621a795a38f56dc60dd6f1792312e75ae8893f4590d4cf23a67395dca945179d0c99601b9e0cdb9fab3fbd7071a92714878481afef512643bc854c47253b
+  data.tar.gz: b84074c9d236764a9e275c130392ef170145072b41c0a64cb361ff5db6eb83f9183c6923305e8104427d1bb7489c038deda25e942fe17a9b8c9d89abbe8a25a7

data/lib/eac_rest/request.rb

@@ -1,88 +1,46 @@
 # frozen_string_literal: true
 
+require 'eac_envs/http/request'
 require 'eac_rest/response'
 require 'eac_ruby_utils/core_ext'
-require 'faraday'
-require 'faraday/multipart'
 
 module EacRest
   class Request
-    BOOLEAN_MODIFIERS = %w[ssl_verify].freeze
-    COMMON_MODIFIERS = %w[auth body_data 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
-
-    common_constructor :url, :body_data_proc, default: [nil]
-
-    def autenticate(username, password)
-      auth(::Struct.new(:username, :password).new(username, password))
-    end
-
-    # @return [Faraday::Connection]
-    def faraday_connection
-      ::Faraday.default_connection_options[:headers] = {}
-      ::Faraday::Connection.new(faraday_connection_options) do |conn|
-        if body_with_file?
-          conn.request :multipart, flat_encode: true
-        else
-          conn.request :url_encoded
-        end
-        auth.if_present { |v| conn.request :authorization, :basic, v.username, v.password }
+    attr_reader :internal_request
+
+    # @param url [EacEnvs::Http::Request, String]
+    # @param response_body_data_proc [Proc, nil]
+    def initialize(url, response_body_data_proc = nil)
+      if url.is_a?(::EacEnvs::Http::Request)
+        @internal_request = url
+      else
+        @internal_request = ::EacEnvs::Http::Request.new.url(url)
+        response_body_data_proc.if_present { |v| @internal_request.response_body_data_proc = v }
       end
     end
 
-    # @return [Hash]
-    def faraday_connection_options
-      {
-        request: { params_encoder: Faraday::FlatParamsEncoder }, ssl: { verify: ssl_verify? }
-      }
-    end
+    delegate :sanitized_verb, to: :internal_request
 
-    # @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 }
+    {
+      auth: 0, body_data: 0, header: 1, headers: 0, ssl_verify: 0, verb: 0
+    }.each do |method_name, read_args_count|
+      define_method method_name do |*args|
+        if args.count <= read_args_count
+          internal_request.send(method_name, *args)
+        else
+          self.class.new(internal_request.send(method_name, *args))
+        end
       end
     end
 
-    def immutable_constructor_args
-      [url, body_data_proc]
+    # @return [EacRest::Request]
+    def autenticate(username, password)
+      self.class.new(internal_request.basic_auth(username, password))
     end
 
+    # @return [EacRest::Response]
     def response
       ::EacRest::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 body_fields
-      @body_fields ||= ::EacRest::Request::BodyFields.new(body_data)
-    end
-
-    # @return [Boolean]
-    def body_with_file?
-      body_fields.with_file?
-    end
-
-    def sanitized_body_data
-      body_fields.to_h || body_data
-    end
-
-    require_sub __FILE__
   end
 end

data/lib/eac_rest/response.rb

@@ -1,111 +1,25 @@
 # frozen_string_literal: true
 
-require 'active_support/core_ext/hash/conversions'
-require 'eac_rest'
+require 'eac_rest/error'
+require 'eac_envs/http/error'
 require 'eac_ruby_utils/core_ext'
-require 'json'
 
 module EacRest
   class Response < ::StandardError
-    HEADER_LINE_PARSER = /\A([^:]+):(.*)\z/.to_parser do |m|
-      [m[1].strip, m[2].strip]
-    end
-
-    # 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
-
     common_constructor :request
     delegate :body_data_proc, to: :request
 
-    def body_data
-      r = performed.headers['Accept'].if_present(body_str) do |v|
-        method_name = "body_data_from_#{v.parameterize.underscore}"
-        respond_to?(method_name) ? send(method_name) : body_str
-      end
-      r = body_data_proc.call(r) if 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
-
-    def header(name)
-      hash_search(headers, name)
-    end
-
-    def headers
-      performed.header_str.each_line.map(&:strip)[1..-1].reject(&:blank?)
-        .map { |header_line| HEADER_LINE_PARSER.parse!(header_line) }
-        .to_h
-    end
-
-    def link(rel)
-      hash_search(links, rel)
+    def internal_response
+      @internal_response ||= request.internal_request.response
     end
 
-    def links
-      header(LINKS_HEADER_NAME).if_present({}) do |v|
-        v.split(',').map { |w| LINK_PARSER.parse!(w.strip) }.to_h
+    %i[body_data body_data_or_raise body_str body_str_or_raise header headers
+       link links raise_unless_200 status to_s url].each do |method_name|
+      define_method method_name do |*args, &block|
+        internal_response.send(method_name, *args, &block)
+      rescue ::EacEnvs::Http::Error
+        raise ::EacRest::Error
       end
     end
-
-    def raise_unless_200
-      return nil if status == 200
-
-      raise self
-    end
-
-    def status
-      performed.status.to_i
-    end
-
-    delegate :url, to: :request
-
-    def to_s
-      "URL: #{url}\nStatus: #{status}\nBody:\n\n#{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
-
-    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
-
-    def performed
-      @performed ||= request.faraday_response
-    rescue ::Faraday::Error
-      raise ::EacRest::Error
-    end
   end
 end

data/lib/eac_rest/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module EacRest
-  VERSION = '0.7.1'
+  VERSION = '0.7.2'
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: eac_rest
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.2
 platform: ruby
 authors:
 - Eduardo H. Bogoni
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-17 00:00:00.000000000 Z
+date: 2023-03-21 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: eac_envs-http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: eac_fs
   requirement: !ruby/object:Gem::Requirement
@@ -131,9 +145,6 @@ files:
 - lib/eac_rest/entity.rb
 - lib/eac_rest/error.rb
 - lib/eac_rest/request.rb
-- lib/eac_rest/request/body_field.rb
-- lib/eac_rest/request/body_field_value.rb
-- lib/eac_rest/request/body_fields.rb
 - lib/eac_rest/response.rb
 - lib/eac_rest/version.rb
 homepage: 

data/lib/eac_rest/request/body_field.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_rest/request/body_field_value'
-require 'eac_ruby_utils/core_ext'
-require 'faraday/multipart/file_part'
-
-module EacRest
-  class Request
-    class BodyField
-      class << self
-        # @return [Array<EacRest::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<EacRest::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| ::EacRest::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

data/lib/eac_rest/request/body_field_value.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_fs/file_info'
-require 'eac_ruby_utils/core_ext'
-require 'faraday'
-require 'faraday/multipart'
-
-module EacRest
-  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

data/lib/eac_rest/request/body_fields.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-require 'eac_rest/request/body_field'
-
-module EacRest
-  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<EacRest::Request::BodyField>, nil]
-      def fields
-        source_body.if_present do |v|
-          next nil unless v.is_a?(::Enumerable)
-
-          if v.is_a?(::Hash)
-            ::EacRest::Request::BodyField.list_from_hash(v)
-          else
-            ::EacRest::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