smooth_operator 1.3.0 → 1.8.0

data/lib/smooth_operator/model_schema.rb

@@ -0,0 +1,72 @@
+module SmoothOperator
+
+  module ModelSchema
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def known_attributes
+      @known_attributes ||= self.class.known_attributes.dup
+    end
+
+    def internal_structure
+      @internal_structure ||= self.class.internal_structure.dup
+    end
+
+    def table_name
+      @table_name ||= self.class.table_name.dup
+    end
+
+    def model_name
+      @model_name ||= table_name.singularize
+    end
+
+    
+    module ClassMethods
+
+      attr_writer :table_name
+
+      def table_name
+        @table_name ||= self.model_name.to_s.downcase.pluralize
+      end
+
+      def schema(structure)
+        internal_structure.merge! Helpers.stringify_keys(structure)
+
+        known_attributes.merge internal_structure.keys
+      end
+
+      def internal_structure
+        Helpers.get_instance_variable(self, :internal_structure, {})
+      end
+
+      def known_attributes
+        Helpers.get_instance_variable(self, :known_attributes, Set.new)
+      end
+
+      def model_name
+        if defined? ActiveModel
+          rails_model_name_method
+        else
+          name.split('::').last.underscore.capitalize
+        end
+      end
+
+      
+      protected ############## PROTECTED #############
+
+      def rails_model_name_method
+        @_model_name ||= begin
+          namespace = self.parents.detect do |n|
+            n.respond_to?(:use_relative_model_naming?) && n.use_relative_model_naming?
+          end
+          ActiveModel::Name.new(self, namespace)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/smooth_operator/open_struct.rb

@@ -1,22 +1,19 @@
-require "smooth_operator/options"
 require "smooth_operator/delegation"
 require "smooth_operator/validations"
-require "smooth_operator/resource_name"
+require "smooth_operator/model_schema"
 require "smooth_operator/serialization"
-require "smooth_operator/internal_data"
 require "smooth_operator/attribute_assignment"
 
 module SmoothOperator
-  class OpenStruct
 
-    extend Options
-    extend ResourceName
+  class OpenStruct
 
     include Delegation
     include Validations
-    include InternalData
+    include ModelSchema
     include Serialization
     include AttributeAssignment
 
   end
+
 end

data/lib/smooth_operator/operator.rb

@@ -1,145 +1,107 @@
-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"
+require 'faraday'
+# require 'typhoeus'
+# require 'faraday_middleware'
+# require 'typhoeus/adapters/faraday'
 
 module SmoothOperator
+
   module Operator
 
-    def make_the_call(http_verb, relative_path = '', data = {}, options = {})
-      options ||= {}
+    HTTP_VERBS = [:get, :post, :put, :patch, :delete]
 
-      relative_path = resource_path(relative_path)
+    OPTIONS = [:endpoint, :endpoint_user, :endpoint_pass, :timeout]
 
-      parent_object = _options[:parent_object]
 
-      if !parent_object.nil? && options[:ignore_parent] != true
-        id = Helpers.primary_key(parent_object)
+    attr_writer *OPTIONS
 
-        options[:resources_name] ||= "#{parent_object.class.resources_name}/#{id}/#{self.class.resources_name}"
-      end
+    OPTIONS.each { |option| define_method(option) { Helpers.get_instance_variable(self, option, '') } }
 
-      call_args = before_request(http_verb, relative_path, data, options)
+    HTTP_VERBS.each { |http_verb| define_method(http_verb) { |relative_path = '', params = {}, options = {}| make_the_call(http_verb, relative_path, params, options) } }
 
-      self.class.make_the_call(*call_args) do |remote_call|
-        yield(remote_call)
-      end
-    end
 
-    def resource_path(relative_path)
-      if Helpers.absolute_path?(relative_path)
-        Helpers.remove_initial_slash(relative_path)
-      elsif persisted?
-        id = Helpers.primary_key(self)
-
-        Helpers.present?(relative_path) ? "#{id}/#{relative_path}" : id.to_s
-      else
-        relative_path
-      end
+    def generate_parallel_connection
+      generate_connection(:typhoeus)
     end
 
-    def self.included(base)
-      base.extend(ClassMethods)
-    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, :server_name]
+    def generate_connection(adapter = nil, options = nil)
+      adapter ||= :net_http
+      options ||= {}
+      url, timeout = (options[:endpoint] || self.endpoint), (options[:timeout] || self.timeout)
 
-      OPTIONS.each do |option|
-        define_method(option) { get_option option, '' }
+      Faraday.new(url: url) do |builder|
+        builder.options.params_encoder = Faraday::NestedParamsEncoder # to properly encode arrays
+        builder.options.timeout = timeout unless Helpers.blank?(timeout)
+        builder.request :url_encoded
+        builder.adapter adapter
       end
+    end
 
-      def headers
-        get_option :headers, {}
-      end
 
-      def make_the_call(http_verb, relative_path = '', data = {}, options = {})
-        options = HelperMethods.populate_options(self, options)
+    protected ################ PROTECTED ################
 
-        resource_path = resource_path(relative_path, options)
+    def make_the_call(http_verb, relative_path = '', data = {}, options = {})
+      params, body = strip_params(http_verb, data)
 
-        http_verb, resource_path, data, options = before_request(http_verb, resource_path, data, options)
+      connection, operator_options, options = strip_options(options)
 
-        params, data = *HelperMethods.strip_params(self, http_verb, data)
+      relative_path = build_relative_path(relative_path, options)
 
-        operator = HelperMethods.get_me_an_operator(options)
+      begin
+        set_basic_authentication(connection, operator_options)
 
-        operator.make_the_call(http_verb, resource_path, params, data, options) do |remote_call|
-          block_given? ? yield(remote_call) : remote_call
+        response = connection.send(http_verb) do |request|
+          operator_options.each { |key, value| request.options.send("#{key}=", value) }
+          params.each { |key, value| request.params[key] = value }
+          
+          request.url relative_path
+          request.body = body
         end
-      end
 
-      def query_string(params)
-        params
+        RemoteCall::Base.new(response)
+      rescue Faraday::ConnectionFailed
+        RemoteCall::ConnectionFailed.new
       end
+    end
 
-      def resource_path(relative_path, options)
-        resources_name = options[:resources_name] || self.resources_name
+    def query_string(options)
+      options
+    end
 
-        if Helpers.present?(resources_name)
-          Helpers.present?(relative_path) ? "#{resources_name}/#{relative_path}" : resources_name
-        else
-          relative_path.to_s
-        end
-      end
 
-      def generate_parallel_connection
-        Operators::Typhoeus.generate_parallel_connection
-      end
+    private ################# PRIVATE ###################
 
-      protected ################# PROTECTED ####################
+    def build_relative_path(relative_path, options)
+      table_name = options[:table_name] || self.table_name
 
-      def before_request(http_verb, relative_path, data, options)
-        [http_verb, relative_path, data, options]
+      if Helpers.present?(table_name)
+        Helpers.present?(relative_path) ? "#{table_name}/#{relative_path}" : table_name
+      else
+        relative_path
       end
-
     end
 
-    module HelperMethods
-
-      extend self
+    def strip_params(http_verb, data)
+      data ||= {}
 
-      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 populate_options(object, options)
-        options ||= {}
-
-        ClassMethods::OPTIONS.each do |option|
-          options[option] ||= object.send(option)
-        end
+      ([:get, :head, :delete].include?(http_verb) ? [query_string(data), nil] : [query_string({}), data])
+    end
 
-        options[:headers] = object.headers.merge(options[:headers] || {})
+    def strip_options(options)
+      options ||= {}
 
-        options
-      end
+      operator_options = options.delete(:operator_options) || {}
+      connection = options.delete(:connection) || generate_connection(nil, operator_options)
 
-      def strip_params(object, http_verb, data)
-        data ||= {}
+      [connection, operator_options, options]
+    end
 
-        if [:get, :head, :delete].include?(http_verb)
-          [object.query_string(data), nil]
-        else
-          [object.query_string({}), data]
-        end
-      end
+    def set_basic_authentication(connection, options)
+      endpoint_user = options[:endpoint_user] || self.endpoint_user
+      endpoint_pass = options[:endpoint_pass] || self.endpoint_pass
 
+      connection.basic_auth(endpoint_user, endpoint_pass) if Helpers.present?(endpoint_user)
     end
 
   end
+
 end

data/lib/smooth_operator/persistence.rb

@@ -1,147 +1,117 @@
 module SmoothOperator
+  
   module Persistence
 
     def self.included(base)
       base.extend(ClassMethods)
     end
 
-    attr_reader :last_remote_call
-
-    def new_record?(ignore_cache = false)
-      return @new_record if !ignore_cache && defined?(@new_record)
-
-      @new_record = Helpers.has_primary_key?(self)
-    end
+    module ClassMethods
 
-    def marked_for_destruction?(ignore_cache = false)
-      if !ignore_cache && defined?(@marked_for_destruction)
-        return @marked_for_destruction
+      def methods_http_verbs
+        @methods_http_verbs ||= { create: :post, save: :put, destroy: :delete }
       end
 
-      _destroy = internal_data_get(self.class.destroy_key)
+      [:create, :save, :destroy].each do |method|
+        define_method("#{method}_http_verb=") { |http_verb| methods_http_verbs[method] = http_verb }
+      end
+      
+      def create(attributes = nil, relative_path = nil, data = {}, options = {})
+        if attributes.is_a?(Array)
+          attributes.map { |array_entry| create(array_entry, relative_path, data, options) }
+        else
+          new(attributes).tap { |object| object.save(relative_path, data, options) }
+        end
+      end
 
-      @marked_for_destruction = TypeCasting::TRUE_VALUES.include?(_destroy)
     end
 
-    def destroyed?
-      return @destroyed if defined?(@destroyed)
 
-      @destroyed = false
+    def new_record?
+      return @new_record if defined?(@new_record)
+      
+      @new_record = Helpers.blank?(get_internal_data("id"))
     end
-
-    def persisted?
-      !(new_record? || destroyed?)
+    
+    def destroyed?
+      @destroyed || false
     end
 
-    def known_attribute?(attribute)
-      super ||
-      [self.class.primary_key, self.class.destroy_key].include?(attribute.to_s)
+    def last_remote_call
+      @last_remote_call
     end
 
-    def reload(relative_path = nil, data = {}, options = {})
-      if Helpers.blank?(relative_path) && Helpers.has_primary_key?(self)
-        raise 'UnknownPath'
-      end
-
-      make_a_persistence_call(:reload, relative_path, data, options) do |remote_call|
-        block_given? ? yield(remote_call) : remote_call.status
-      end
+    def persisted?
+      !(new_record? || destroyed?)
     end
 
     def save(relative_path = nil, data = {}, options = {})
-      resource_data = resource_data_for_server(data)
-
-      method = new_record? ? :create : :update
-
-      make_a_persistence_call(method, relative_path, resource_data, options) do |remote_call|
-        @new_record = false if method == :create && remote_call.status
+      create_or_update(relative_path, data, options)
+    end
 
-        block_given? ? yield(remote_call) : remote_call.status
-      end
+    def save!(relative_path = nil, data = {}, options = {})
+      create_or_update(relative_path, data, options) || raise('RecordNotSaved')
     end
 
     def destroy(relative_path = nil, data = {}, options = {})
       return false unless persisted?
 
-      make_a_persistence_call(:destroy, relative_path, data, options) do |remote_call|
-        @destroyed = true if remote_call.status
+      relative_path = "#{id}" if Helpers.blank?(relative_path)
+      
+      success = make_remote_call(self.class.methods_http_verbs[:destroy], relative_path, data, options)
 
-        block_given? ? yield(remote_call) : remote_call.status
-      end
-    end
+      @destroyed = true if success
 
-    def save!(relative_path = nil, data = {}, options = {})
-      save(relative_path, data, options) do |remote_call|
-        block_given? ? yield(remote_call) : remote_call.status
-      end || raise('RecordNotSaved')
+      success
     end
 
-    protected ######################### PROTECTED ##################
 
-    def internal_data_for_server
-      data = self.class.get_option(:internal_data_for_server, false)
+    protected ######################### PROTECTED ##################
 
-      if data == false
-        serializable_hash.dup.tap { |hash| hash.delete(self.class.primary_key) }
-      else
-        data
-      end
+    def create_or_update(relative_path, data, options)
+      new_record? ? create(relative_path, data, options) : update(relative_path, data, options)
     end
 
-    def resource_data_for_server(data)
-      resource_data =
-        self.class.get_option(:resource_data_for_server, false, data)
+    def create(relative_path, data, options)
+      success = make_remote_call(self.class.methods_http_verbs[:create], relative_path, data, options)
 
-      if resource_data == false
-        data = Helpers.stringify_keys(data)
-        resource_data = Helpers.stringify_keys(internal_data_for_server)
+      @new_record = false if success
 
-        { self.class.resource_name.to_s => resource_data }.merge(data)
-      else
-        resource_data
-      end
+      success
     end
 
-    private ##################### PRIVATE ##################
-
-    def make_a_persistence_call(method, relative_path, data, options)
-      options ||= {}
-
-      http_verb = options[:http_verb] || self.class.http_verb_for(method)
-
-      make_the_call(http_verb, relative_path, data, options) do |remote_call|
-        @last_remote_call = remote_call
-
-        if !@last_remote_call.error? && @last_remote_call.parsed_response.is_a?(Hash)
-          assign_attributes @last_remote_call.parsed_response, data_from_server: true
-        end
+    def update(relative_path, data, options)
+      relative_path = "#{id}" if Helpers.blank?(relative_path)
 
-        yield(remote_call)
-      end
+      make_remote_call(self.class.methods_http_verbs[:save], relative_path, data, options)
     end
 
-    module ClassMethods
 
-      METHODS_VS_HTTP_VERBS = { reload: :get, create: :post, update: :put, destroy: :delete }
+    private ##################### PRIVATE ####################
 
-      def http_verb_for(method)
-        get_option "#{method}_http_verb".to_sym, METHODS_VS_HTTP_VERBS[method]
-      end
+    def make_remote_call(http_verb, relative_path, data, options)
+      data, options = build_remote_call_args(http_verb, data, options)
 
-      def primary_key
-        get_option :primary_key, 'id'
-      end
+      @last_remote_call = self.class.send(http_verb, relative_path, data, options)
 
-      def destroy_key
-        get_option :destroy_key, '_destroy'
+      returning_data = @last_remote_call.parsed_response
+      
+      if !@last_remote_call.error? && returning_data.is_a?(Hash)
+        assign_attributes returning_data.include?(model_name) ? returning_data[model_name] : returning_data
       end
 
-      def create(attributes = nil, relative_path = nil, data = {}, options = {})
-        new(attributes).tap do |object|
-          object.save(relative_path, data, options)
-        end
-      end
+      @last_remote_call.status
+    end
 
+    def build_remote_call_args(http_verb, data, options)
+      return [data, options] if http_verb == :delete
+      
+      hash = serializable_hash(options[:serializable_options]).dup
+      hash.delete('id')
+
+      [{ model_name => hash }.merge(data), options]
     end
+
   end
+  
 end