smooth_operator 0.4.4 → 1.2.0

data/lib/smooth_operator/operators/typhoeus.rb

@@ -0,0 +1,77 @@
+require 'typhoeus'
+require "smooth_operator/remote_call/typhoeus"
+
+module SmoothOperator
+
+  module Operators
+
+    module Typhoeus
+
+      extend self
+
+      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.queue(request)
+
+        request.on_complete do |typhoeus_response|          
+          _remote_call = remote_call(typhoeus_response)
+
+          yield(_remote_call) if block_given?
+        end
+
+        hydra.run if Helpers.blank?(options[:hydra])
+
+        _remote_call
+      end
+
+
+      protected ################ PROTECTED ################
+
+      def typhoeus_request_args(http_verb, relative_path, params, body, options)
+        [url(options, relative_path), build_typhoeus_options(http_verb, params, body, options)]
+      end
+
+      def remote_call(typhoeus_response)
+        if typhoeus_response.return_code == :couldnt_connect
+          RemoteCall::Errors::ConnectionFailed
+        elsif typhoeus_response.timed_out?
+          RemoteCall::Errors::Timeout
+        else
+          RemoteCall::Typhoeus
+        end.new(typhoeus_response)
+      end
+
+
+      private ################### PRIVATE ###############
+
+      def build_typhoeus_options(http_verb, params, body, options)
+        typhoeus_options = { method: http_verb, headers: options[:headers].merge({ "Content-type" => "application/x-www-form-urlencoded" }) }
+
+        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])
+
+        typhoeus_options
+      end
+
+      def url(options, relative_path)
+        url = options[:endpoint]
+        
+        slice = url[-1] != '/' ? '/' : ''
+
+        url = "#{url}#{slice}#{relative_path}" if Helpers.present?(relative_path)
+      end
+
+    end
+
+  end
+end

data/lib/smooth_operator/persistence.rb

@@ -0,0 +1,144 @@
+module SmoothOperator
+  module Persistence
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    attr_reader :last_remote_call
+
+    def get_primary_key
+      get_internal_data(self.class.primary_key)
+    end
+
+    def reload(relative_path = nil, data = {}, options = {})
+      raise 'UnknownPath' if Helpers.blank?(relative_path) && (!respond_to?(self.class.primary_key) || Helpers.blank?(get_primary_key))
+
+      persistence_call(:reload, relative_path, data, options) do |remote_call|
+        block_given? ? yield(remote_call) : remote_call.status
+      end
+    end
+
+    def new_record?(bypass_cache = false)
+      return @new_record if !bypass_cache && defined?(@new_record)
+
+      @new_record = Helpers.blank?(get_primary_key)
+    end
+
+    def marked_for_destruction?(bypass_cache = false)
+      return @marked_for_destruction if !bypass_cache && defined?(@marked_for_destruction)
+
+      @marked_for_destruction = ["true", "1", true].include?(get_internal_data(self.class.destroy_key))
+    end
+
+    def destroyed?
+      return @destroyed if defined?(@destroyed)
+
+      @destroyed = false
+    end
+
+    def persisted?
+      !(new_record? || destroyed?)
+    end
+
+    def save(relative_path = nil, data = {}, options = {})
+      data = data_with_object_attributes(data, options)
+
+      if new_record?
+        create(relative_path, data, options) { |remote_call| block_given? ? yield(remote_call) : remote_call.status }
+      else
+        update(relative_path, data, options) { |remote_call| block_given? ? yield(remote_call) : remote_call.status }
+      end
+    end
+
+    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')
+    end
+
+    def destroy(relative_path = nil, data = {}, options = {})
+      return false unless persisted?
+
+      persistence_call(:destroy, relative_path, data, options) do |remote_call|
+        @destroyed = true if remote_call.status
+
+        block_given? ? yield(remote_call) : remote_call.status
+      end
+    end
+
+
+    protected ######################### PROTECTED ##################
+
+    def create(relative_path, data, options)
+      persistence_call(:create, relative_path, data, options) do |remote_call|
+        @new_record = false if remote_call.status
+
+        block_given? ? yield(remote_call) : remote_call
+      end
+    end
+
+    def update(relative_path, data, options)
+      persistence_call(:update, relative_path, data, options) do |remote_call|
+        block_given? ? yield(remote_call) : remote_call
+      end
+    end
+
+    def persistence_call(method, relative_path, data, options)
+      options ||= {}
+
+      http_verb = options[:http_verb] || self.class.methods_vs_http_verbs[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, from_server: true
+        end
+
+        yield(remote_call)
+      end
+    end
+
+    def data_with_object_attributes(data, options)
+      data = Helpers.stringify_keys(data)
+
+      hash = serializable_hash(options[:serializable_options]).dup
+
+      hash.delete(self.class.primary_key)
+
+      { self.class.resource_name => hash }.merge(data)
+    end
+
+
+    module ClassMethods
+
+      METHODS_VS_HTTP_VERBS = { reload: :get, create: :post, update: :put, destroy: :delete }
+
+      def methods_vs_http_verbs
+        Helpers.get_instance_variable(self, :methods_vs_http_verbs, METHODS_VS_HTTP_VERBS.dup)
+      end
+
+      def primary_key
+        Helpers.get_instance_variable(self, :primary_key, 'id')
+      end
+
+      attr_writer :primary_key
+
+      def destroy_key
+        Helpers.get_instance_variable(self, :destroy_key, '_destroy')
+      end
+
+      attr_writer :destroy_key
+
+      METHODS_VS_HTTP_VERBS.keys.each do |method|
+        define_method("#{method}_http_verb=") { |http_verb| methods_vs_http_verbs[method] = http_verb }
+      end
+
+      def create(attributes = nil, relative_path = nil, data = {}, options = {})
+        new(attributes).tap { |object| object.save(relative_path, data, options) }
+      end
+
+    end
+  end
+end

data/lib/smooth_operator/relation/array_relation.rb

@@ -0,0 +1,13 @@
+require "smooth_operator/relation/single_relation"
+
+module SmoothOperator
+  module Relation
+    class ArrayRelation < SingleRelation
+
+      def reload2
+        "TODO2"
+      end
+
+    end
+  end
+end

data/lib/smooth_operator/relation/association_reflection.rb

@@ -0,0 +1,75 @@
+require "smooth_operator/relation/reflection"
+
+module SmoothOperator
+  module Relation
+    class AssociationReflection < Reflection
+
+      attr_reader :related_reflection, :macro
+
+      def initialize(association, related_reflection, options)
+        super(association, options)
+        @macro = options[:macro] || macro_default(association)
+        @related_reflection = related_reflection
+      end
+
+      def primary_key
+        @primary_key ||= options[:primary_key] || :id
+      end
+
+      def foreign_key
+        @foreign_key ||= options[:foreign_key] || foreign_key_default
+      end
+
+      def set_relational_keys(origin, destination)
+        return nil if options[:standalone] == true
+
+        if has_many? || has_one?
+          set_foreign_key(destination, primary_key_of(origin))
+        elsif belongs_to?
+          set_foreign_key(origin, primary_key_of(destination))
+        end
+      end
+
+      def set_foreign_key(object, id)
+        setter = "#{foreign_key}="
+
+        if object.respond_to?(setter)
+          object.send(setter, id)
+        elsif object.respond_to?("send_to_representative")
+          object.send_to_representative(setter, id)
+        end
+      end
+
+      def primary_key_of(object)
+        object.send(primary_key)
+      end
+
+      def has_many?
+        macro == :has_many
+      end
+
+      def has_one?
+        macro == :has_one
+      end
+
+      def belongs_to?
+        macro == :belongs_to
+      end
+
+      private ################################# private
+
+      def macro_default(association)
+        Helpers.plural?(association) ? :has_many : :belongs_to
+      end
+
+      def foreign_key_default
+        if has_many? || has_one?
+          "#{related_reflection.single_name}_id"
+        elsif belongs_to?
+          "#{single_name}_id"
+        end.to_sym
+      end
+
+    end
+  end
+end

data/lib/smooth_operator/relation/associations.rb

@@ -0,0 +1,75 @@
+require "smooth_operator/relation/array_relation"
+require "smooth_operator/relation/association_reflection"
+
+module SmoothOperator
+  module Relation
+    module Associations
+
+      def relations
+        @relations ||= {}
+      end
+
+      def get_relation(relation_name)
+        relations[relation_name] ||= self.class.build_relation(relation_name, get_internal_data(relation_name))
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def has_many(nested_object_name, options = {})
+          accepts_nested_objects(nested_object_name, :has_many, options)
+        end
+
+        def has_one(nested_object_name, options = {})
+          accepts_nested_objects(nested_object_name, :has_one, options)
+        end
+
+        def belongs_to(nested_object_name, options = {})
+          accepts_nested_objects(nested_object_name, :belongs_to, options)
+        end
+
+        def reflections
+          Helpers.get_instance_variable(self, :reflections, {})
+        end
+
+        def reflect_on_association(association)
+          reflections[association]
+        end
+
+        def reflect_on_all_associations(macro = nil)
+          macro ? reflections.values.select { |reflection| reflection.macro == macro } : reflections.values
+        end
+
+        def build_relation(relation_name, data)
+          if reflections[relation_name.to_sym].has_many?
+            ArrayRelation.new(data || [], relation_name)
+          else
+            SingleRelation.new(data, relation_name)
+          end
+        end
+
+        protected ###################### PROTECTED ###################
+
+        def accepts_nested_objects(nested_object_name, macro, options = {})
+          default_options = { macro: macro }
+          options = options.is_a?(Hash) ? options.merge(default_options) : default_options
+          options = Helpers.symbolyze_keys(options)
+
+          reflection = AssociationReflection.new(nested_object_name, Reflection.new(name, {}), options)
+
+          self.send(:attr_accessor, "#{nested_object_name}_attributes".to_sym)
+          self.instance_variable_set("@reflections", reflections.merge(nested_object_name => reflection))
+
+          define_method("existing_#{nested_object_name}") { existing_nested_objects(nested_object_name) }
+          define_method("build_#{reflection.single_name}") { |attributes = {}, nested_object = nil| build_nested_object(nested_object_name, attributes, nested_object) }
+
+          schema(nested_object_name => reflection.klass)
+        end
+
+      end
+    end
+  end
+end

data/lib/smooth_operator/relation/reflection.rb

@@ -0,0 +1,41 @@
+module SmoothOperator
+  module Relation
+    class Reflection
+
+      attr_reader :name, :klass, :options
+
+      def initialize(class_name, options)
+        options = options.is_a?(Hash) ? options : {}
+
+        @name, @options = class_name, options
+
+        @klass = options[:class_name] || klass_default(@name)
+
+        if options.include?(:class_name) && options[:class_name].nil?
+          @klass = nil
+        elsif @klass.is_a?(String)
+          @klass = @klass.constantize
+        end
+      end
+
+      def single_name
+        @single_name ||= options[:single_name] || name.to_s.singularize
+      end
+
+      def plural_name
+        @plural_name ||= options[:plural_name] || name.to_s.pluralize
+      end
+
+      private ################################# private
+
+      def klass_default(class_name)
+        if Helpers.plural?(class_name)
+          class_name.to_s.singularize.camelize
+        else
+          class_name.to_s.camelize
+        end
+      end
+
+    end
+  end
+end

data/lib/smooth_operator/relation/single_relation.rb

@@ -0,0 +1,14 @@
+module SmoothOperator
+  module Relation
+    class SingleRelation < ::SimpleDelegator
+
+      attr_reader :relation_name
+
+      def initialize(object, relation_name)
+        @relation_name = relation_name
+        super(object)
+      end
+
+    end
+  end
+end

data/lib/smooth_operator/remote_call/base.rb

@@ -0,0 +1,80 @@
+module SmoothOperator
+
+  module RemoteCall
+
+    class Base
+
+      extend Forwardable
+
+      attr_reader :response, :http_status, :body, :headers
+
+      attr_accessor :object
+
+      def initialize(response)
+        @response = response
+      end
+
+
+      def ok?
+        http_status.between?(200, 299) || http_status == 304
+      end
+
+      def not_processed?
+        http_status == 422
+      end
+
+      def error?
+        !ok? && !not_processed?
+      end
+
+      def client_error?
+        http_status.between?(400, 499)
+      end
+
+      def server_error?
+        http_status.between?(500, 599) || http_status == 0
+      end
+
+
+      def not_found?
+        http_status == 404
+      end
+
+      def timeout?
+        false
+      end
+
+      def connection_failed?
+        false
+      end
+
+
+      def parsed_response
+        return nil if body.nil?
+        
+        require 'json' unless defined? JSON
+        
+        begin
+          JSON.parse(body)
+        rescue JSON::ParserError
+          nil
+        end
+      end
+
+      def status
+        error? ? nil : ok?
+      end
+
+      def objects
+        object.respond_to?(:length) ? object : []
+      end
+
+      def data
+        object.nil? ? parsed_response : object
+      end
+
+    end
+
+  end
+
+end

data/lib/smooth_operator/remote_call/errors/connection_failed.rb

@@ -0,0 +1,20 @@
+module SmoothOperator
+  module RemoteCall
+    module Errors
+
+      class ConnectionFailed < Base
+
+        def initialize(response)
+          super
+          @http_status = 0
+        end
+
+        def connection_failed?
+          true
+        end
+
+      end
+
+    end
+  end
+end

data/lib/smooth_operator/remote_call/errors/timeout.rb

@@ -0,0 +1,20 @@
+module SmoothOperator
+  module RemoteCall
+    module Errors
+
+      class Timeout < Base
+
+        def initialize(response)
+          super
+          @http_status = 0
+        end
+
+        def timeout?
+          true
+        end
+
+      end
+
+    end
+  end
+end

data/lib/smooth_operator/remote_call/faraday.rb

@@ -0,0 +1,19 @@
+module SmoothOperator
+
+  module RemoteCall
+
+    class Faraday < Base
+
+      def initialize(response)
+        @response = response
+
+        @body = response.body
+        @headers = response.headers
+        @http_status = response.status
+      end
+
+    end
+
+  end
+
+end

data/lib/smooth_operator/remote_call/typhoeus.rb

@@ -0,0 +1,19 @@
+module SmoothOperator
+
+  module RemoteCall
+
+    class Typhoeus < Base
+
+      def initialize(response)
+        @response = response
+
+        @body = response.body
+        @http_status = response.code
+        @headers = response.headers_hash
+      end
+
+    end
+
+  end
+
+end

data/lib/smooth_operator/serialization.rb

@@ -0,0 +1,79 @@
+module SmoothOperator
+
+  module Serialization
+
+    def to_hash(options = nil)
+      Helpers.symbolyze_keys(serializable_hash(options) || {})
+    end
+    
+    # alias :attributes :to_hash
+    def attributes; to_hash; end
+    
+    def to_json(options = nil)
+      require 'json' unless defined? JSON
+      
+      JSON(serializable_hash(options) || {})
+    end
+
+    def read_attribute_for_serialization(attribute)
+      send(attribute)
+    end
+
+    def serializable_hash(options = nil)
+      hash = {}
+      options ||= {}
+
+      attribute_names(options).each do |attribute_name|
+        hash[attribute_name] = read_attribute_for_hashing(attribute_name, options)
+      end
+
+      method_names(options).each do |method_name|
+        hash[method_name.to_s] = send(method_name)
+      end
+
+      hash
+    end
+
+
+    protected ##################### PROTECTED ###################
+    
+    # TODO: COMPLEX METHOD
+    def attribute_names(options)
+      attribute_names = internal_data.keys.sort
+
+      if only = options[:only]
+        attribute_names &= [*only].map(&:to_s)
+      elsif except = options[:except]
+        attribute_names -= [*except].map(&:to_s)
+      end
+
+      attribute_names
+    end
+
+    def method_names(options)
+      [*options[:methods]].select { |n| respond_to?(n) }
+    end
+
+    def read_attribute_for_hashing(attribute_name, options)
+      object = read_attribute_for_serialization(attribute_name)
+
+      _options = options[attribute_name] || options[attribute_name.to_sym]
+
+      if object.is_a?(Array)
+        object.map { |array_entry| attribute_to_hash(array_entry, _options) }
+      else
+        attribute_to_hash(object, _options)
+      end
+    end
+
+    def attribute_to_hash(object, options = nil)
+      if object.respond_to?(:serializable_hash)
+        Helpers.symbolyze_keys(object.serializable_hash(options))
+      else
+        object
+      end
+    end
+
+  end
+
+end