restool 0.1.4 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 584d88793980824115720aa0e0f037d0fae8c35439c4e24e16e33dc902b11e8b
-  data.tar.gz: 7adca6d17ead07b51bbe097b273e655e5ff34d365bbc95ffb33620e70588cffa
+  metadata.gz: a30917334428d8500580624813b39b56a4e56e8fae18f01399f23fd5f24aebca
+  data.tar.gz: aabdff9a61d0b7e9e976c1e88aec8af63ce511fa72b6b01ef97f2f961c0150ee
 SHA512:
-  metadata.gz: 0b93df06284266885ce45b9e83849a7125ed2d0f4bd82a236b5ea751aaa7860136aeaad9f248dd3ad5d6ab21d3948469a82973cbe0a19812a578d57cb43d4c55
-  data.tar.gz: d1a7b15cfc046896fc3b57d9092c1ffe33f50d21a1d8645327b68b7a28259b3e47ee9349e74115d77028c5b02cbf26607c995a4f9c9db0e6b2f7e02796d30bbb
+  metadata.gz: 8ce2c12b769a4605c6163d2102df036cc74c596b0477720c229e2abd7aa7f7851e3b09dc436590654373cb5758144cc1ee93ca6b7ddd8eed2fd4294ae0ab965f
+  data.tar.gz: 45e6f37d33a8bd228ceb15caec3234cfaa9642cced28eb5e85c3ebb64f435fa7cf2e3a504046ca5ddedf1921c2dc850d4cd0420872b106680eaa010554d8046a

data/lib/restool.rb

@@ -1,11 +1,10 @@
 require_relative 'restool/settings/loader'
 require_relative 'restool/service/restool_service'
 
-
 module Restool
 
-  def self.create(service_name, &response_handler)
-    service_config = Restool::Settings::Loader.load(service_name)
+  def self.create(service_name, opts = {}, &response_handler)
+    service_config = Restool::Settings::Loader.load(service_name, opts)
 
     Restool::Service::RestoolService.new(service_config, response_handler)
   end

data/lib/restool/errors.rb

@@ -0,0 +1,7 @@
+module Restool
+
+  class Error < StandardError
+  end
+
+
+end

data/lib/restool/logger/request_logger.rb

@@ -0,0 +1,55 @@
+module Restool
+  class RequestLogger
+
+    def initialize(host, opts)
+      @host = host
+      @opts = opts
+    end
+
+    def log(request, &http_request)
+      log_request(request) if log?
+      response = http_request.call
+      log_response(response) if log?
+
+      response
+    rescue StandardError => e
+      log_error(e) if log?
+
+      raise
+    end
+
+    def logger
+      @opts[:logger]
+    end
+
+    def log?
+      if @opts[:log] != nil
+        @opts[:log]
+      else
+        @opts[:logger] != nil
+      end
+    end
+
+    private
+
+    def log_request(request)
+      logger.info  { "Restool Service #{@host}" }
+      logger.info  { "#{request.method.upcase} #{request.path}" }
+      logger.info  { "Headers: { #{format_hash(request.headers)} }" }
+      logger.debug { "Params: { #{format_hash(request.params)} }" }
+    end
+
+    def log_response(response)
+      logger.info  { "Restool response (status #{response.code}):" }
+      logger.debug { response.body }
+    end
+
+    def log_error(error)
+      logger.error { "Restool error: #{error}" }
+    end
+
+    def format_hash(headers)
+      headers.map { |key, value| "#{key}: #{value}" }.join(", ")
+    end
+  end
+end

data/lib/restool/mock/restool.rb

@@ -0,0 +1,32 @@
+require_relative '../settings/loader'
+
+module Restool
+  module Mock
+    def self.create(service_name, operation_responses)
+      @operation_responses = operation_responses
+      @service_config = Restool::Settings::Loader.load(service_name)
+
+      Service.new(@service_config, operation_responses)
+    end
+
+    private
+
+    class Service
+      def initialize(service_config, operation_responses)
+        @service_config = service_config
+        @operation_responses = operation_responses
+      end
+
+      def method_missing(method, *args, &block)
+        if @service_config.operations.map(&:name).include?(method)
+          operation_response      = @operation_responses[method]
+          response_representation = @service_config.operation.response
+          representations         = @service_config.representations
+
+          Restool::Traversal::Converter.convert(operation_response, response_representation, representations)
+        end
+      end
+    end
+
+  end
+end

data/lib/restool/service/operation_request.rb

@@ -0,0 +1,15 @@
+module Restool
+  class OperationRequest
+
+    attr_accessor :http_request, :method, :path, :params, :headers
+
+    def initialize(http_request, method, path, params, headers)
+      @http_request = http_request
+      @method = method
+      @path = path
+      @params = params
+      @headers = headers
+    end
+
+  end
+end

data/lib/restool/service/remote_client.rb

@@ -1,45 +1,43 @@
-require 'persistent_http'
-
+require "net/http"
+require "net/https"
 require_relative 'request_utils'
+require_relative '../logger/request_logger'
 
 module Restool
   module Service
     class RemoteClient
 
-      def initialize(host, verify_ssl, persistent_connection, timeout)
-        @connection = if persistent_connection
-                        PersistentHTTP.new(
-                          pool_size:    persistent_connection.pool_size,
-                          pool_timeout: timeout,
-                          warn_timeout: persistent_connection.warn_timeout,
-                          force_retry:  persistent_connection.force_retry,
-                          url:          host,
-                          read_timeout: timeout,
-                          open_timeout: timeout,
-                          verify_mode: verify_ssl?(verify_ssl)
-                        )
-                      else
-                        uri               = URI.parse(host)
-                        http              = Net::HTTP.new(uri.host, uri.port)
-                        http.use_ssl      = ssl_implied?(uri)
-                        http.verify_mode  = verify_ssl?(verify_ssl)
-                        http.read_timeout = timeout
-                        http.open_timeout = timeout
-                        # http.set_debug_output($stdout)
-                        http
-                      end
+      def initialize(host, verify_ssl, timeout, opts)
+        @request_logger = Restool::RequestLogger.new(host, opts)
+        @connection = build_connection(host, verify_ssl, timeout, opts)
       end
 
       def make_request(path, method, request_params, headers, basic_auth)
-        request = RequestUtils.build_request(method, path, request_params, headers, basic_auth)
-
-        @connection.request(request)
+        operation_request = RequestUtils.build_request(method, path, request_params, headers, basic_auth)
+
+        @request_logger.log(operation_request) do
+          @connection.request(operation_request.http_request)
+        end
+      rescue Errno::ETIMEDOUT => e
+        raise Restool::TimeoutError, e
+      rescue Errno::EADDRNOTAVAIL, Errno::ECONNREFUSED, IOError, SocketError
+        raise Restool::ConnectionFailed, $ERROR_INFO
       end
 
       private
 
-      def ssl_implied?(uri)
-        uri.port == 443 || uri.scheme == 'https'
+      def build_connection(host, verify_ssl, timeout, opts)
+        uri = URI.parse(host)
+
+        connection = Net::HTTP.new(uri.host, uri.port)
+
+        connection.use_ssl      = uri.is_a?(URI::HTTPS)
+        connection.verify_mode  = verify_ssl?(verify_ssl)
+        connection.read_timeout = timeout
+        connection.open_timeout = timeout
+        connection.set_debug_output($stdout) if opts[:debug]
+
+        connection
       end
 
       def verify_ssl?(verify_ssl_setting)

data/lib/restool/service/request_utils.rb

@@ -1,3 +1,5 @@
+require_relative 'operation_request'
+
 module Restool
   module Service
     module RequestUtils
@@ -23,7 +25,7 @@ module Restool
 
         headers.each { |k, v| request[k] = v } if headers
 
-        request
+        OperationRequest.new(request, method, path, params, headers)
       end
 
       def self.build_base_request(method, path)

data/lib/restool/service/restool_service.rb

@@ -11,7 +11,7 @@ module Restool
         @service_config = service_config
         @response_handler = response_handler
         @remote_client = Restool::Service::RemoteClient.new(service_config.host, service_config.verify_ssl,
-                                                            service_config.persistent, service_config.timeout)
+                                                            service_config.timeout, service_config.opts)
 
         define_operations(
           @service_config, method(:make_request), method(:make_request_with_uri_params)

data/lib/restool/settings/loader.rb

@@ -11,37 +11,28 @@ module Restool
       DEFAULT_SSL_VERIFY = false
 
 
-      def self.load(service_name)
+      def self.load(service_name, opts)
         service_config = config['services'].detect do |service|
-          service['name'] == service_name
+          service['name'] == service_name.to_s
         end
 
         raise "Service #{service_name} not found in configuration" unless service_config
 
-        build_service(service_config)
+        build_service(service_config, opts)
       end
 
       private
 
-      def self.build_service(service_config)
+      def self.build_service(service_config, opts)
         representations = if service_config['representations']
                             build_representations(service_config['representations'])
                           else
                             []
                           end
 
-        basic_auth = service_config['basic_auth'] || service_config['basic_authentication']
+        basic_auth = opts['basic_auth'] || opts['basic_authentication'] || service_config['basic_auth'] || service_config['basic_authentication']
         basic_auth = BasicAuthentication.new(basic_auth['user'], basic_auth['password']) if basic_auth
 
-        persistent_connection = service_config['persistent']
-        persistent_connection = if persistent_connection
-                                  PersistentConnection.new(
-                                    persistent_connection['pool_size'],
-                                    persistent_connection['warn_timeout'],
-                                    persistent_connection['force_retry'],
-                                  )
-                                end
-
         # Support host + common path in url config, e.g. api.com/v2/
         paths_prefix_in_host = URI(service_config['url']).path
 
@@ -49,11 +40,11 @@ module Restool
           service_config['name'],
           service_config['url'],
           service_config['operations'].map { |operation| build_operation(operation, paths_prefix_in_host) },
-          persistent_connection,
           service_config['timeout'] || DEFAULT_TIMEOUT,
           representations,
           basic_auth,
-          service_config['ssl_verify'] || DEFAULT_SSL_VERIFY
+          service_config['ssl_verify'] || DEFAULT_SSL_VERIFY,
+          opts
         )
       end
 
@@ -105,7 +96,7 @@ module Restool
       def self.config
         return @config if @config
 
-        files_to_load = Dir['config/restool/*'] + ['config/restool.yml', 'config/restool.json']
+        files_to_load = Dir['config/restool/*.yml'] + Dir['config/restool/*.yaml'] + ['config/restool.yml', 'config/restool.yaml', 'config/restool.json']
 
         @config = { 'services' => [] }
 
@@ -114,12 +105,12 @@ module Restool
 
           extension = File.extname(file_name)
 
-          content = if extension == '.yml'
-            YAML.load_file(file_name)
-          elsif extension == '.json'
-            json_file = File.read(file_name)
-            JSON.parse(json_file)
-          end
+          content = if extension == '.yml' || extension == '.yaml'
+                      YAML.load_file(file_name)
+                    elsif extension == '.json'
+                      json_file = File.read(file_name)
+                      JSON.parse(json_file)
+                    end
 
           @config['services'] += content['services']
         end
@@ -127,10 +118,6 @@ module Restool
         @config
       end
 
-      def self.validate
-        # TODO: perform validations
-      end
-
     end
   end
 end

data/lib/restool/settings/models.rb

@@ -4,11 +4,10 @@ module Restool
 
       Operation = Struct.new(:name, :path, :method, :uri_params, :response)
       OperationResponse = Struct.new(:fields)
-      Service = Struct.new(:name, :host, :operations, :persistent, :timeout, :representations, :basic_auth, :verify_ssl)
+      Service = Struct.new(:name, :host, :operations, :timeout, :representations, :basic_auth, :verify_ssl, :opts)
       Representation = Struct.new(:name, :fields)
       RepresentationField = Struct.new(:key, :metonym, :type)
       BasicAuthentication = Struct.new(:user, :password)
-      PersistentConnection = Struct.new(:respool_size, :want_timeout, :force_retry)
       OperationResponsField = RepresentationField
 
     end

data/lib/restool/traversal/converter.rb

@@ -19,6 +19,9 @@ module Restool
       def self.convert(request_response, response_representation, representations)
         object = Restool::Traversal::Object.new
 
+        object.class.__send__(:attr_accessor, :_raw)
+        object.__send__("_raw=", request_response)
+
         if request_response.is_a?(Array)
           request_response.map do |element|
             map_response_to_representation(response_representation, element, object, representations)
@@ -32,15 +35,15 @@ module Restool
 
       def self.map_response_to_representation(representation, request_response, object, representations)
         representation.fields.each do |field|
-          value = request_response[field.key]
+          value = request_response[field.key.to_s] || request_response[field.key.to_sym]
+
+          object.class.__send__(:attr_accessor, var_name(field))
 
           if value.nil?
             set_var(object, field, nil)
             next
           end
 
-          object.class.__send__(:attr_accessor, var_name(field))
-
           if Restool::Traversal::TRAVERSAL_TYPES.include?(field.type.to_sym)
             map_primitive_field(value, field, object)
           else

data/lib/restool/traversal/object.rb

@@ -1,17 +1,5 @@
 module Restool
   module Traversal
-    class Object
-
-      def to_hash
-        instance_variables
-          .inject({}) do |acum, var|
-            acum[var.to_s.delete('@')] = instance_variable_get(var)
-            acum
-          end
-      end
-
-      alias_method :to_h, :to_hash
-
-    end
+    class Object; end
   end
 end

data/lib/restool/version.rb

@@ -1,3 +1,3 @@
 module Restool
-  VERSION = '0.1.4'
+  VERSION = '1.0.2'
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: restool
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 1.0.2
 platform: ruby
 authors:
 - Juan Andres Zeni
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-04-20 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: persistent_http
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2'
+date: 2020-11-28 00:00:00.000000000 Z
+dependencies: []
 description: Make HTTP requests and handle its responses using simple method calls.
   Restool turns your HTTP API and its responses into Ruby interfaces.
 email:
@@ -33,7 +19,11 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/restool.rb
+- lib/restool/errors.rb
+- lib/restool/logger/request_logger.rb
+- lib/restool/mock/restool.rb
 - lib/restool/service/operation_definer.rb
+- lib/restool/service/operation_request.rb
 - lib/restool/service/remote_client.rb
 - lib/restool/service/remote_connector.rb
 - lib/restool/service/request_utils.rb
@@ -48,7 +38,7 @@ homepage: https://github.com/jzeni/restool
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -63,8 +53,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
-signing_key: 
+rubygems_version: 3.2.0.rc.1
+signing_key:
 specification_version: 4
 summary: Turn your API and its responses into Ruby interfaces.
 test_files: []