smooth_operator 1.2.9 → 1.3.0

data/lib/smooth_operator/finder_methods.rb

@@ -1,43 +1,52 @@
 require 'smooth_operator/array_with_meta_data'
 
 module SmoothOperator
-  
   module FinderMethods
 
     def find(relative_path, data = {}, options = {})
       relative_path = '' if relative_path == :all
 
       get(relative_path, data, options) do |remote_call|
-        remote_call.object = build_object(remote_call.parsed_response, options) if remote_call.ok?
+        if remote_call.ok?
+          remote_call.object = HelperMethods
+            .build_object(self, remote_call.parsed_response, options)
+        end
 
         block_given? ? yield(remote_call) : remote_call
       end
     end
 
+    module HelperMethods
 
-    protected #################### PROTECTED ##################
+      extend self
 
-    def build_object(parsed_response, options, from_array = false)
-      if parsed_response.is_a?(Array)
-        parsed_response.map { |array_entry| build_object(array_entry, options, true) }
-      elsif parsed_response.is_a?(Hash)
-        if parsed_response.include?(object_class.resources_name) && !from_array
-          ArrayWithMetaData.new(parsed_response, object_class)
+      def build_object(object, parsed_response, options, from_array = false)
+        if parsed_response.is_a?(Array)
+          parse_array(parsed_response, object, options)
+        elsif parsed_response.is_a?(Hash)
+          parse_hash(object, parsed_response, options, from_array)
         else
-          object_class.new(parsed_response, from_server: true)
+          parsed_response
+        end
+      end
+
+      def parse_array(parsed_response, object, options)
+        parsed_response.map do |array_entry|
+          build_object(object, array_entry, options, true)
         end
-      else
-        parsed_response
       end
-    end
 
+      def parse_hash(object, parsed_response, options, from_array)
+        object_class ||= object.class == Class ? object : object.class
 
-    private #################### PRIVATE ##################
+        if parsed_response.include?(object_class.resources_name) && !from_array
+          ArrayWithMetaData.new(parsed_response.dup, object_class)
+        else
+          object_class.new(parsed_response, data_from_server: true)
+        end
+      end
 
-    def object_class
-      @object_class ||= self.class == Class ? self : self.class
     end
 
   end
-  
 end

data/lib/smooth_operator/helpers.rb

@@ -4,16 +4,22 @@ module SmoothOperator
 
     extend self
 
-    def safe_call(object, method, *args)
-      if object.respond_to?(method)
-        object.send(method, *args)
-      else
-        false
-      end
+    def generated_id
+      Time.now.to_f.to_s.split('.')[1]
+    end
+
+    def primary_key(object)
+      object.internal_data_get(object.class.primary_key)
+    end
+
+    def has_primary_key?(object)
+      blank? primary_key(object)
     end
 
     def super_method(object, method_name, *args)
-      object.superclass.send(method_name, *args) if object.superclass.respond_to?(method_name)
+      if object.superclass.respond_to?(method_name)
+        object.superclass.send(method_name, *args)
+      end
     end
 
     def get_instance_variable(object, variable, default_value)
@@ -56,7 +62,7 @@ module SmoothOperator
       case object
       when String
         object.to_s == ''
-      when Array
+      when Array, Hash
         object.empty?
       else
         object.nil?

data/lib/smooth_operator/http_methods.rb

@@ -0,0 +1,17 @@
+module SmoothOperator
+  module HttpMethods
+
+    HTTP_VERBS = %w[get post put patch delete]
+
+    HTTP_VERBS.each do |method|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(relative_path = '', params = {}, options = {})
+          make_the_call(:#{method}, relative_path, params, options) do |remote_call|
+            block_given? ? yield(remote_call) : remote_call
+          end
+        end
+      RUBY
+    end
+
+  end
+end

data/lib/smooth_operator/internal_data.rb

@@ -0,0 +1,45 @@
+require 'smooth_operator/type_casting'
+
+module SmoothOperator
+  module InternalData
+
+    def internal_data
+      @internal_data ||= {}
+    end
+
+    def known_attributes
+      return @known_attributes if defined?(@known_attributes)
+
+      schema_attributes = if self.class.respond_to?(:internal_structure)
+        self.class.internal_structure.keys
+      else
+        []
+      end
+
+      @known_attributes = Set.new(schema_attributes)
+    end
+
+    def known_attribute?(attribute)
+      known_attributes.include?(attribute.to_s)
+    end
+
+    def internal_data_get(attribute_name)
+      internal_data[attribute_name]
+    end
+
+    def internal_data_push(attribute_name, attribute_value)
+      attribute_name = attribute_name.to_s
+
+      known_attributes.add attribute_name
+
+      internal_data[attribute_name] = TypeCasting.cast_to_type(attribute_name, attribute_value, self)
+
+      if self.class.respond_to?(:smooth_operator?)
+        marked_for_destruction?(attribute_value) if attribute_name == self.class.destroy_key
+
+        new_record?(true) if attribute_name == self.class.primary_key
+      end
+    end
+
+  end
+end

data/lib/smooth_operator/open_struct.rb

@@ -1,37 +1,22 @@
+require "smooth_operator/options"
 require "smooth_operator/delegation"
 require "smooth_operator/validations"
-require "smooth_operator/model_schema"
+require "smooth_operator/resource_name"
 require "smooth_operator/serialization"
-require "smooth_operator/attribute_methods"
+require "smooth_operator/internal_data"
 require "smooth_operator/attribute_assignment"
 
 module SmoothOperator
-  module OpenStruct
+  class OpenStruct
 
-    class Base
+    extend Options
+    extend ResourceName
 
-      include Delegation
-      include Validations
-      include ModelSchema
-      include Serialization
-      include AttributeMethods
-      include AttributeAssignment
-
-      def self.strict_behaviour=(value)
-        @strict_behaviour = value
-      end
-
-      def self.strict_behaviour
-        Helpers.get_instance_variable(self, :strict_behaviour, false)
-      end
-
-    end
-
-    class Dirty < Base
-
-      dirty_attributes
-
-    end
+    include Delegation
+    include Validations
+    include InternalData
+    include Serialization
+    include AttributeAssignment
 
   end
 end

data/lib/smooth_operator/operator.rb

@@ -2,6 +2,7 @@ require "smooth_operator/remote_call/base"
 require "smooth_operator/operators/faraday"
 require "smooth_operator/operators/typhoeus"
 require "smooth_operator/remote_call/errors/timeout"
+require "smooth_operator/operators/connection_wrapper"
 require "smooth_operator/remote_call/errors/connection_failed"
 
 module SmoothOperator
@@ -12,72 +13,67 @@ module SmoothOperator
 
       relative_path = resource_path(relative_path)
 
+      parent_object = _options[:parent_object]
+
       if !parent_object.nil? && options[:ignore_parent] != true
-        options[:resources_name] ||= "#{parent_object.class.resources_name}/#{parent_object.get_primary_key}/#{self.class.resources_name}"
+        id = Helpers.primary_key(parent_object)
+
+        options[:resources_name] ||= "#{parent_object.class.resources_name}/#{id}/#{self.class.resources_name}"
       end
 
-      self.class.make_the_call(http_verb, relative_path, data, options) do |remote_call|
+      call_args = before_request(http_verb, relative_path, data, options)
+
+      self.class.make_the_call(*call_args) do |remote_call|
         yield(remote_call)
       end
     end
 
-    protected ######################## PROTECTED ###################
-
     def resource_path(relative_path)
       if Helpers.absolute_path?(relative_path)
         Helpers.remove_initial_slash(relative_path)
       elsif persisted?
-        Helpers.present?(relative_path) ? "#{get_primary_key}/#{relative_path}" : get_primary_key.to_s
+        id = Helpers.primary_key(self)
+
+        Helpers.present?(relative_path) ? "#{id}/#{relative_path}" : id.to_s
       else
         relative_path
       end
     end
 
-    ########################### MODULES BELLOW ###############################
-
-    module HttpMethods
-
-      HTTP_VERBS = %w[get post put patch delete]
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
 
-      HTTP_VERBS.each do |method|
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{method}(relative_path = '', params = {}, options = {})
-            make_the_call(:#{method}, relative_path, params, options) do |remote_call|
-              block_given? ? yield(remote_call) : remote_call
-            end
-          end
-        RUBY
-      end
+    protected ################# PROTECTED ####################
 
+    def before_request(http_verb, relative_path, data, options)
+      [http_verb, relative_path, data, options]
     end
 
     module ClassMethods
 
-      OPTIONS = [:endpoint, :endpoint_user, :endpoint_pass, :timeout]
+      OPTIONS = [:endpoint, :endpoint_user, :endpoint_pass, :timeout, :server_name]
 
       OPTIONS.each do |option|
-        define_method(option) { Helpers.get_instance_variable(self, option, '') }
+        define_method(option) { get_option option, '' }
       end
 
-      attr_writer *OPTIONS
-
       def headers
-        Helpers.get_instance_variable(self, :headers, {})
+        get_option :headers, {}
       end
 
-      attr_writer :headers
+      def make_the_call(http_verb, relative_path = '', data = {}, options = {})
+        options = HelperMethods.populate_options(self, options)
 
+        resource_path = resource_path(relative_path, options)
 
-      def make_the_call(http_verb, relative_path = '', data = {}, options = {})
-        operator_args = operator_method_args(http_verb, relative_path, data, options)
+        http_verb, resource_path, data, options = before_request(http_verb, resource_path, data, options)
 
-        if Helpers.present?(operator_args[4][:hydra])
-          operator_call = Operators::Typhoeus
-        else
-          operator_call = Operators::Faraday
-        end
+        params, data = *HelperMethods.strip_params(self, http_verb, data)
 
-        operator_call.make_the_call(*operator_args) do |remote_call|
+        operator = HelperMethods.get_me_an_operator(options)
+
+        operator.make_the_call(http_verb, resource_path, params, data, options) do |remote_call|
           block_given? ? yield(remote_call) : remote_call
         end
       end
@@ -86,54 +82,64 @@ module SmoothOperator
         params
       end
 
-      protected #################### PROTECTED ##################
+      def resource_path(relative_path, options)
+        resources_name = options[:resources_name] || self.resources_name
 
-      def operator_method_args(http_verb, relative_path, data, options)
-        options = populate_options(options)
+        if Helpers.present?(resources_name)
+          Helpers.present?(relative_path) ? "#{resources_name}/#{relative_path}" : resources_name
+        else
+          relative_path.to_s
+        end
+      end
 
-        [http_verb, resource_path(relative_path, options), *strip_params(http_verb, data), options]
+      def generate_parallel_connection
+        Operators::Typhoeus.generate_parallel_connection
       end
 
-      private #################### PRIVATE ##################
+      protected ################# PROTECTED ####################
 
-      def populate_options(options)
-        options ||= {}
+      def before_request(http_verb, relative_path, data, options)
+        [http_verb, relative_path, data, options]
+      end
 
-        OPTIONS.each { |option| options[option] ||= send(option) }
+    end
 
-        options[:headers] = headers.merge(options[:headers] || {})
+    module HelperMethods
 
-        options
+      extend self
+
+      def get_me_an_operator(options)
+        if options[:parallel_connection].nil?
+          Operators::Faraday
+        else
+          options[:connection] = options.delete(:parallel_connection)
+          Operators::Typhoeus
+        end
       end
 
-      def resource_path(relative_path, options)
-        _resources_name = options[:resources_name] || self.resources_name
+      def populate_options(object, options)
+        options ||= {}
 
-        if Helpers.present?(_resources_name)
-          Helpers.present?(relative_path) ? "#{_resources_name}/#{relative_path}" : _resources_name
-        else
-          relative_path.to_s
+        ClassMethods::OPTIONS.each do |option|
+          options[option] ||= object.send(option)
         end
+
+        options[:headers] = object.headers.merge(options[:headers] || {})
+
+        options
       end
 
-      def strip_params(http_verb, data)
+      def strip_params(object, http_verb, data)
         data ||= {}
 
         if [:get, :head, :delete].include?(http_verb)
-          [query_string(data), nil]
+          [object.query_string(data), nil]
         else
-          [query_string({}), data]
+          [object.query_string({}), data]
         end
       end
-    end
-
-    include HttpMethods
 
-    def self.included(base)
-      base.extend(ClassMethods)
-      base.extend(HttpMethods)
     end
 
   end
-
 end

data/lib/smooth_operator/operators/connection_wrapper.rb

@@ -0,0 +1,15 @@
+module SmoothOperator
+  class ConnectionWrapper
+
+    attr_reader :connection
+
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def run
+      connection.run
+    end
+
+  end
+end

data/lib/smooth_operator/operators/faraday.rb

@@ -17,11 +17,11 @@ module SmoothOperator
       def generate_connection(adapter = nil, options = nil)
         adapter ||= :net_http
 
-        ::Faraday.new(url: options[:endpoint]) do |builder|
+        ConnectionWrapper.new(::Faraday.new(url: options[:endpoint]) do |builder|
           builder.options[:timeout] = options[:timeout].to_i unless Helpers.blank?(options[:timeout])
           builder.request :url_encoded
           builder.adapter adapter
-        end
+        end)
       end
 
       def make_the_call(http_verb, resource_path, params, body, options)
@@ -49,8 +49,8 @@ module SmoothOperator
 
       def strip_options(options)
         request_options = options.delete(:request_options) || {}
-        
-        connection = options.delete(:connection) || generate_connection(nil, options)
+
+        connection = (options.delete(:connection) || generate_connection(nil, options)).connection
 
         [connection, request_options, options]
       end
@@ -61,9 +61,9 @@ module SmoothOperator
 
       def request_configuration(request, request_options, options, params, body)
         request_options.each { |key, value| request.options.send("#{key}=", value) }
-        
+
         options[:headers].each { |key, value| request.headers[key] = value }
-        
+
         params.each { |key, value| request.params[key] = value }
 
         request.body = body

data/lib/smooth_operator/operators/typhoeus.rb

@@ -9,27 +9,38 @@ module SmoothOperator
 
       extend self
 
+      def generate_parallel_connection
+        generate_connection
+      end
+
+      def generate_connection(adapter = nil, options = nil)
+        ConnectionWrapper.new(::Typhoeus::Hydra::hydra)
+      end
+
       def make_the_call(http_verb, resource_path, params, body, options)
         request = ::Typhoeus::Request.new *typhoeus_request_args(http_verb, resource_path, params, body, options)
-        
-        hydra = options[:hydra] || ::Typhoeus::Hydra::hydra
 
-        _remote_call = nil
+        hydra = (options[:connection] || generate_connection).connection
+
+        request_result = nil
 
         hydra.queue(request)
 
-        request.on_complete do |typhoeus_response|          
-          _remote_call = remote_call(typhoeus_response)
+        request.on_complete do |typhoeus_response|
+          remote_call = remote_call(typhoeus_response)
 
-          yield(_remote_call) if block_given?
+          if block_given?
+            request_result = yield(remote_call)
+          else
+            request_result = remote_call
+          end
         end
 
-        hydra.run if Helpers.blank?(options[:hydra])
+        hydra.run if Helpers.blank?(options[:connection])
 
-        _remote_call
+        request_result
       end
 
-
       protected ################ PROTECTED ################
 
       def typhoeus_request_args(http_verb, relative_path, params, body, options)
@@ -46,7 +57,6 @@ module SmoothOperator
         end.new(typhoeus_response)
       end
 
-
       private ################### PRIVATE ###############
 
       def build_typhoeus_options(http_verb, params, body, options)
@@ -55,7 +65,7 @@ module SmoothOperator
         typhoeus_options[:timeout] = options[:timeout] if Helpers.present?(options[:timeout])
 
         typhoeus_options[:body] = body if Helpers.present?(body)
-        
+
         typhoeus_options[:params] = params if Helpers.present?(params)
 
         typhoeus_options[:userpwd] = "#{options[:endpoint_user]}:#{options[:endpoint_pass]}" if Helpers.present?(options[:endpoint_user])
@@ -65,7 +75,7 @@ module SmoothOperator
 
       def url(options, relative_path)
         url = options[:endpoint]
-        
+
         slice = url[-1] != '/' ? '/' : ''
 
         url = "#{url}#{slice}#{relative_path}" if Helpers.present?(relative_path)

data/lib/smooth_operator/options.rb

@@ -0,0 +1,30 @@
+module SmoothOperator
+  module Options
+
+    def get_option(option, default, *args)
+      return default unless config_options.include?(option)
+
+      _option = config_options[option]
+
+      case _option
+      when Symbol
+        respond_to?(_option) ? send(_option, *args) : _option
+      when Proc
+        _option.call(*args)
+      else
+        _option
+      end
+    end
+
+    def config_options
+      Helpers.get_instance_variable(self, :config_options, {})
+    end
+
+    def smooth_operator_options(options = {})
+      config_options.merge!(options)
+    end
+
+    alias_method :options, :smooth_operator_options
+
+  end
+end