restool 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 00b59168b2f8bf6dda90e1764dfb4e86b31fc35b9467a6dbe128fa456747cfe3
+  data.tar.gz: '09267a1659146bfafdc1433ea3164f071f8f9af8325c405dbb145918ec630aa5'
+SHA512:
+  metadata.gz: bc937386969581255334f5c648b1241c2eb59867f54cb4eaa2c968c6a3f1a1c29d781ef8ad621a554a4c21a2e35f576d20c7de0ba873c8383db784596f318943
+  data.tar.gz: 6dae0d57818581ce78f335b814adc9921f81ffa5279d7848b0612dc8b657ba15226740c6e254df86e99f53c60e99c75c3fd99546a477d86dc600f860d408ea2b

data/lib/restool.rb

@@ -0,0 +1,13 @@
+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)
+
+    Restool::Service::RestoolService.new(service_config, response_handler)
+  end
+
+end

data/lib/restool/service/operation_definer.rb

@@ -0,0 +1,31 @@
+require_relative 'uri_utils'
+
+module Restool
+  module Service
+    module OperationDefiner
+
+      def define_operations(service_config, method_make_request, method_make_request_with_uri_params)
+        service_config.operations.each do |operation|
+          if operation.uri_params != []
+            define_request_method_with_uri_params(operation, method_make_request_with_uri_params)
+          else
+            define_request_method(operation, method_make_request)
+          end
+        end
+      end
+
+      def define_request_method_with_uri_params(operation, method_make_request_with_uri_params)
+        define_singleton_method(operation.name) do |uri_params_values, *params|
+          method_make_request_with_uri_params.call(operation, uri_params_values, params[0], params[1])
+        end
+      end
+
+      def define_request_method(operation, method_make_request)
+        define_singleton_method(operation.name) do |*params|
+          method_make_request.call(operation, params[0], params[1])
+        end
+      end
+
+    end
+  end
+end

data/lib/restool/service/remote_client.rb

@@ -0,0 +1,50 @@
+require 'persistent_http'
+
+require_relative 'request_utils'
+
+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
+      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)
+      end
+
+      private
+
+      def ssl_implied?(uri)
+        uri.port == 443 || uri.scheme == 'https'
+      end
+
+      def verify_ssl?(verify_ssl_setting)
+        verify_ssl_setting ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE
+      end
+    end
+  end
+end

data/lib/restool/service/remote_connector.rb

@@ -0,0 +1,24 @@
+require_relative '../traversal/converter'
+
+module Restool
+  module Service
+    module RemoteConnector
+      # The RemoteConnector module makes the requests using the RemoteClient,
+      # calls the response_handler with the response, and finally executes
+      # the object traversal
+
+      def self.execute(remote_client, operation, path, params, headers,
+                      response_handler, representations, basic_auth)
+        remote_response = remote_client.make_request(path, operation.method, params, headers,
+                                                    basic_auth)
+
+        response = response_handler.call(remote_response.body, remote_response.code)
+
+        return response if operation.response.nil?
+
+        Restool::Traversal::Converter.convert(response, operation.response, representations)
+      end
+
+    end
+  end
+end

data/lib/restool/service/request_utils.rb

@@ -0,0 +1,46 @@
+module Restool
+  module Service
+    module RequestUtils
+
+      def self.build_request(method, path, params, headers, basic_auth)
+        if ['post', 'put', 'patch'].include?(method)
+          request = build_base_request(method, path)
+
+          if params && params.is_a?(Hash)
+            request.set_form_data(params)
+          else
+            request.body = params
+          end
+
+        else
+          uri = URI(path)
+          uri.query = URI.encode_www_form(params) if params
+
+          request = build_base_request(method, uri.to_s)
+        end
+
+        request.basic_auth(basic_auth.user, basic_auth.password) if basic_auth
+
+        headers.each { |k, v| request[k] = v } if headers
+
+        request
+      end
+
+      def self.build_base_request(method, path)
+        case method.to_s.downcase
+        when 'get'
+          Net::HTTP::Get.new(path)
+        when 'post'
+          Net::HTTP::Post.new(path)
+        when 'put'
+          Net::HTTP::Put.new(path)
+        when 'delete'
+          Net::HTTP::Delete.new(path)
+        when 'patch'
+          Net::HTTP::Patch.new(path)
+        end
+      end
+
+    end
+  end
+end

data/lib/restool/service/restool_service.rb

@@ -0,0 +1,44 @@
+require_relative 'remote_client'
+require_relative 'remote_connector'
+require_relative 'operation_definer'
+
+module Restool
+  module Service
+    class RestoolService
+      include Restool::Service::OperationDefiner
+
+      def initialize(service_config, response_handler)
+        @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)
+
+        define_operations(
+          @service_config, method(:make_request), method(:make_request_with_uri_params)
+        )
+      end
+
+      private
+
+      # this methods are called directly from the client though the OperationDefiner
+
+      def make_request(operation, params, headers = {})
+        path = Restool::Service::UriUtils.build_path(operation)
+
+        Restool::Service::RemoteConnector.execute(
+          @remote_client, operation, path, params, headers, @response_handler,
+          @service_config.representations, @service_config.basic_auth
+        )
+      end
+
+      def make_request_with_uri_params(operation, uri_params_values, params, headers = {})
+        path = Restool::Service::UriUtils.build_path(operation, uri_params_values)
+
+        Restool::Service::RemoteConnector.execute(
+          @remote_client, operation, path, params, headers, @response_handler,
+          @service_config.representations, @service_config.basic_auth
+        )
+      end
+    end
+  end
+end

data/lib/restool/service/uri_utils.rb

@@ -0,0 +1,20 @@
+module Restool
+  module Service
+    module UriUtils
+
+      def self.build_path(operation, uri_params_values = nil)
+        path = operation.path
+
+        if uri_params_values
+          operation.uri_params.each_with_index do |uri_param, i|
+            path.sub!(/#{uri_param}/, uri_params_values[i].to_s)
+          end
+        end
+
+        path
+      end
+
+    end
+
+  end
+end

data/lib/restool/settings/loader.rb

@@ -0,0 +1,136 @@
+require 'yaml'
+
+require_relative 'models'
+
+module Restool
+  module Settings
+    module Loader
+      include Restool::Settings::Models
+
+      DEFAULT_TIMEOUT    = 60
+      DEFAULT_SSL_VERIFY = false
+
+
+      def self.load(service_name)
+        service_config = config['services'].detect do |service|
+          service['name'] == service_name
+        end
+
+        raise "Service #{service_name} not found in configuration" unless service_config
+
+        build_service(service_config)
+      end
+
+      private
+
+      def self.build_service(service_config)
+        representations = if service_config['representations']
+                            build_representations(service_config['representations'])
+                          else
+                            []
+                          end
+
+        basic_auth = 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
+
+        Models::Service.new(
+          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
+        )
+      end
+
+      def self.build_representations(representations)
+        representations_by_name = {}
+
+        representations.each do |representation|
+          fields = representation[1].map do |field|
+            RepresentationField.new(field['key'],
+                              field['metonym'],
+                              field['type'].to_sym)
+          end
+
+          representation = Representation.new(name = representation.first, fields)
+          representations_by_name[representation.name.to_sym] = representation
+        end
+
+        representations_by_name
+      end
+
+      def self.build_operation(operation_config, paths_prefix_in_host)
+        response = build_operation_response(operation_config['response']) if operation_config['response']
+
+        path = operation_config['path']
+        path = path[1..-1] if path[0] == '/'
+        paths_prefix_in_host.chomp!('/')
+
+        Operation.new(
+          operation_config['name'],
+          "#{paths_prefix_in_host}/#{path}",
+          operation_config['method'],
+          uri_params(operation_config),
+          response
+        )
+      end
+
+      def self.build_operation_response(response)
+        response_fields = response.map do |field|
+                            OperationResponsField.new(field['key'], field['metonym'], field['type'].to_sym)
+                          end
+
+        OperationResponse.new(response_fields)
+      end
+
+      def self.uri_params(operation_config)
+        operation_config['path'].scan(/:[a-zA-Z_]+[0-9]*[a-zA-Z_]*/)
+      end
+
+      def self.config
+        return @config if @config
+
+        files_to_load = Dir['config/restool/*'] + ['config/restool.yml', 'config/restool.json']
+
+        @config = { 'services' => [] }
+
+        files_to_load.each do |file_name|
+          next unless File.exist?(file_name)
+
+          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
+
+          @config['services'] += content['services']
+        end
+
+        @config
+      end
+
+      def self.validate
+        # TODO: perform validations
+      end
+
+    end
+  end
+end

data/lib/restool/settings/models.rb

@@ -0,0 +1,16 @@
+module Restool
+  module Settings
+    module Models
+
+      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)
+      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
+  end
+end

data/lib/restool/traversal/converter.rb

@@ -0,0 +1,91 @@
+require 'bigdecimal'
+
+require_relative 'object'
+
+module Restool
+  module Traversal
+
+    TRAVERSAL_TYPE_STRING    = :string
+    TRAVERSAL_TYPE_INTEGER   = :integer
+    TRAVERSAL_TYPE_DECIMAL   = :decimal
+    TRAVERSAL_TYPE_BOOLEAN   = :boolean
+
+    TRAVERSAL_TYPES = [
+      TRAVERSAL_TYPE_STRING, TRAVERSAL_TYPE_INTEGER, TRAVERSAL_TYPE_DECIMAL, TRAVERSAL_TYPE_BOOLEAN
+    ]
+
+    module Converter
+
+      def self.convert(request_response, response_representation, representations)
+        object = Restool::Traversal::Object.new
+
+        if request_response.is_a?(Array)
+          request_response.map do |element|
+            map_response_to_representation(response_representation, element, object, representations)
+          end
+        else
+          map_response_to_representation(response_representation, request_response, object, representations)
+        end
+      end
+
+      private
+
+      def self.map_response_to_representation(representation, request_response, object, representations)
+        representation.fields.each do |field|
+          value = request_response[field.key]
+
+          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
+            map_complex_field(value, field, object, representations)
+          end
+        end
+
+        object
+      end
+
+      def self.map_primitive_field(value, field, object)
+        new_value = if value.is_a?(Array)
+                      value.map { |element| parse_value(field.type, element) }
+                    else
+                      parse_value(field.type, value)
+                    end
+
+        object.__send__("#{var_name(field)}=", new_value)
+      end
+
+      def self.map_complex_field(value, field, object, representations)
+        operation_representation = representations[field.type.to_sym]
+
+        new_value = if value.is_a?(Array)
+                      value.map { |element| convert(element, operation_representation, representations) }
+                    else
+                      convert(value, operation_representation, representations)
+                    end
+
+        object.__send__("#{var_name(field)}=", new_value)
+      end
+
+      def self.var_name(field)
+        field.metonym || field.key
+      end
+
+      def self.parse_value(type, value)
+        case type
+        when Restool::Traversal::TRAVERSAL_TYPE_STRING
+          value
+        when Restool::Traversal::TRAVERSAL_TYPE_INTEGER
+          Integer(value)
+        when Restool::Traversal::TRAVERSAL_TYPE_DECIMAL
+          BigDecimal.new(scalar)
+        when Restool::Traversal::TRAVERSAL_TYPE_BOOLEAN
+          value.downcase == 'true'
+        end
+      end
+
+    end
+
+  end
+end

data/lib/restool/traversal/object.rb

@@ -0,0 +1,17 @@
+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
+  end
+end

data/lib/restool/version.rb

@@ -0,0 +1,3 @@
+module Restool
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: restool
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Juan Andres Zeni
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-04-11 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'
+description: Make HTTP requests and handle its responses using simple method calls
+  Restool turns your HTTP API and its responses into Ruby interfaces.
+email:
+- juanandreszeni@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/restool.rb
+- lib/restool/service/operation_definer.rb
+- lib/restool/service/remote_client.rb
+- lib/restool/service/remote_connector.rb
+- lib/restool/service/request_utils.rb
+- lib/restool/service/restool_service.rb
+- lib/restool/service/uri_utils.rb
+- lib/restool/settings/loader.rb
+- lib/restool/settings/models.rb
+- lib/restool/traversal/converter.rb
+- lib/restool/traversal/object.rb
+- lib/restool/version.rb
+homepage: https://github.com/jzeni/restool
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: Turn your API and its responses into Ruby interfaces.
+test_files: []