smooth_operator 1.10.24 → 1.11.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZWMwNWQwNzAzNzdiMzI3NTE3OTZiNDY0ZGYxM2JkNzZlZTg5MjBmZA==
+    NjZhOWFjNmFiNDQzZGFjZGJkYjIwYzQ2ZjgxM2JmZWE0ZDg1NTJmMQ==
   data.tar.gz: !binary |-
-    NjI2NThhZThlYzQ1ZDEwYTY3MjU3ZGM0MjZjM2JjYTNhYTBkMWU3ZQ==
+    YjUwZDA4ZmE4NWRjZjczNGRkM2QxMTNmYWYzNjc3MzBiN2E2ZDk4Nw==
 SHA512:
   metadata.gz: !binary |-
-    YTU5MDZhODAwMjZjMDdiYTRhY2E3ODA5MWE0OTRiYWNkYTEwNDgxYzQ3YmE5
-    OWYwMjc5MmM4MDc2OWU2OTI3OTRkNjg4MGY2MTI3MmU2MjMxZmNmYmEyNzUx
-    ZjMxMTQ1NmQ3Y2MyMDZlZjhiNzZhMzA3YTBmMGVkZTljOTU4YzU=
+    YzdlMjdiNzVjOTUwN2JlOTQwOTVkZjIyOTM4N2E5MDQ5NDQxNjZkOTg2YzYw
+    YTAyYmE4MWYyZmQyMzZkYjUxYjlmODBhMjEyZGM2Yjg3MjNkNGNmZTVmMmU1
+    YmZhZTk3NWEyNDkxMmJhN2FlNWJlYTZhNmM5ZTJiOTU1ZTAwYzc=
   data.tar.gz: !binary |-
-    NmY3YTE5MThjZjA5MGQ2MWYxNzI3ZDBmZDBiMjc5NGU5MDAwODlhYTQ4NmRi
-    NjI2OWFiYjE4ZTZlOWFhODgzZWJiYTQxMTc5ODk4NzEzM2YzNDUxMTc5ODI3
-    ODcyMDg0YjYwZjBhOTBlYWM3ZmI5NGUxMzU0ZGI4MjZlZmVhM2Y=
+    MGE1MDlhN2M5ODk3M2FhZWZlZmZjNzc3ZTZmZjZlZjk5MDNkNzkxOGNkM2Yz
+    ZTVjYzI5YjcwYzAyZTQwZjRlNmNmODU5NDRiOWY3Nzc5MDMzMmViNjNhNGU5
+    NTI4OTJhMTIxNzk1MGE5M2FhN2M2NWFjZWZiNzQ2OWM1NWNjNGM=

data/lib/smooth_operator.rb

@@ -10,13 +10,12 @@ module SmoothOperator
   
   class Base < OpenStruct::Base
 
-    extend Operator
     extend FinderMethods
     extend Translation if defined? I18n
 
+    include Operator
     include Persistence
-
-    attr_reader :last_remote_call
+    include FinderMethods
 
     self.strict_behaviour = true
 

data/lib/smooth_operator/array_with_meta_data.rb

@@ -6,15 +6,12 @@ module SmoothOperator
 
     include Enumerable
 
-    attr_reader :meta_data, :internal_array, :object_class
+    attr_reader :meta_data, :internal_array
 
     def_delegators :internal_array, :length, :<<, :[]
 
     def initialize(attributes, object_class)
-      _attributes = attributes.dup
-
-      @object_class = object_class
-      _resources_name = object_class.resources_name
+      _attributes, _resources_name = attributes.dup, object_class.resources_name
 
       @internal_array = [*_attributes[_resources_name]].map { |array_entry| object_class.new(array_entry).tap { |object| object.reloaded = true } }
       _attributes.delete(_resources_name)

data/lib/smooth_operator/attribute_assignment.rb

@@ -111,6 +111,10 @@ module SmoothOperator
       else
         update_internal_data(attribute_name, attribute_value, cast)
       end
+
+      if self.class.respond_to?(:identificator) && attribute_name == self.class.identificator
+        new_record?(true)
+      end
     end
 
     

data/lib/smooth_operator/finder_methods.rb

@@ -4,10 +4,6 @@ module SmoothOperator
   
   module FinderMethods
 
-    # def all(data = {}, options = {})
-    #   find(:all, data, options)
-    # end
-
     def find(relative_path, data = {}, options = {})
       relative_path = '' if relative_path == :all
 
@@ -22,21 +18,26 @@ module SmoothOperator
     protected #################### PROTECTED ##################
 
     def build_object(parsed_response, options, from_array = false)
-      options ||={}
-
       if parsed_response.is_a?(Array)
         parsed_response.map { |array_entry| build_object(array_entry, options, true) }
       elsif parsed_response.is_a?(Hash)
-        if !from_array && parsed_response.include?(resources_name)
-          ArrayWithMetaData.new(parsed_response, self)
+        if parsed_response.include?(object_class.resources_name) && !from_array
+          ArrayWithMetaData.new(parsed_response, object_class)
         else
-          new(parsed_response, from_server: true)
+          object_class.new(parsed_response, from_server: true)
         end
       else
         parsed_response
       end
     end
 
+
+    private #################### PRIVATE ##################
+
+    def object_class
+      @object_class ||= self.class == Class ? self : self.class
+    end
+
   end
   
 end

data/lib/smooth_operator/helpers.rb

@@ -53,6 +53,14 @@ module SmoothOperator
     def present?(object)
       !blank?(object)
     end
+
+    def absolute_path?(string)
+      present?(string) && string[0] == '/'
+    end
+
+    def remove_initial_slash(string)
+      string[1..-1]
+    end
     
   end
   

data/lib/smooth_operator/model_schema.rb

@@ -14,6 +14,7 @@ module SmoothOperator
       @internal_structure ||= self.class.internal_structure.dup
     end
     
+    
     module ClassMethods
       
       def resources_name(default_bypass = nil)

data/lib/smooth_operator/operator.rb

@@ -8,90 +8,136 @@ module SmoothOperator
 
   module Operator
 
-    OPTIONS = [:endpoint, :endpoint_user, :endpoint_pass, :timeout]
+    def make_the_call(http_verb, relative_path = '', data = {}, options = {})
+      options ||= {}
+      
+      relative_path = resource_path(relative_path)
+      
+      if !parent_object.nil? && options[:ignore_parent] != true
+        options[:resources_name] ||= "#{parent_object.class.resources_name}/#{parent_object.get_identificator}/#{self.class.resources_name}"
+      end
+      
+      self.class.make_the_call(http_verb, relative_path, data, options) do |remote_call|
+        yield(remote_call)
+      end
+    end
+
+    protected ######################## PROTECTED ###################
 
-    OPTIONS.each do |option|
-      define_method(option) { Helpers.get_instance_variable(self, option, '') }
+    def resource_path(relative_path)
+      if Helpers.absolute_path?(relative_path)
+        Helpers.remove_initial_slash(relative_path)
+      elsif persisted?
+        Helpers.present?(relative_path) ? "#{get_identificator}/#{relative_path}" : get_identificator.to_s
+      else
+        relative_path
+      end
     end
 
-    attr_writer *OPTIONS
-    
-    %w[get post put patch delete].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
+
+    ########################### MODULES BELLOW ###############################
+
+    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
-        end
-      RUBY
+        RUBY
+      end
+
     end
 
+    module ClassMethods
 
-    def headers
-      Helpers.get_instance_variable(self, :headers, {})
-    end
+      OPTIONS = [:endpoint, :endpoint_user, :endpoint_pass, :timeout]
 
-    attr_writer :headers
+      OPTIONS.each do |option|
+        define_method(option) { Helpers.get_instance_variable(self, option, '') }
+      end
 
+      attr_writer *OPTIONS
 
-    def make_the_call(http_verb, relative_path = '', data = {}, options = {})
-      operator_args = operator_method_args(http_verb, relative_path, data, options)
+      def headers
+        Helpers.get_instance_variable(self, :headers, {})
+      end
 
-      if Helpers.present?(operator_args[4][:hydra])
-        operator_call = Operators::Typhoeus
-      else
-        operator_call = Operators::Faraday
+      attr_writer :headers
+
+
+      def make_the_call(http_verb, relative_path = '', data = {}, options = {})
+        operator_args = operator_method_args(http_verb, relative_path, data, options)
+
+        if Helpers.present?(operator_args[4][:hydra])
+          operator_call = Operators::Typhoeus
+        else
+          operator_call = Operators::Faraday
+        end
+        
+        operator_call.make_the_call(*operator_args) do |remote_call|
+          block_given? ? yield(remote_call) : remote_call
+        end
       end
-      
-      operator_call.make_the_call(*operator_args) do |remote_call|
-        block_given? ? yield(remote_call) : remote_call
+
+      def query_string(params)
+        params
       end
-    end
 
-    def query_string(params)
-      params
-    end
 
+      protected #################### PROTECTED ##################
 
-    protected #################### PROTECTED ##################
+      def operator_method_args(http_verb, relative_path, data, options)
+        options = populate_options(options)
 
-    def operator_method_args(http_verb, relative_path, data, options)
-      options = populate_options(options)
+        [http_verb, resource_path(relative_path, options), *strip_params(http_verb, data), options]
+      end
 
-      [http_verb, resource_path(relative_path, options), *strip_params(http_verb, data), options]
-    end
 
+      private #################### PRIVATE ##################
 
-    private #################### PRIVATE ##################
+      def populate_options(options)
+        options ||= {}
 
-    def populate_options(options)
-      options ||= {}
+        OPTIONS.each { |option| options[option] ||= send(option) }
 
-      OPTIONS.each { |option| options[option] ||= send(option) }
+        options[:headers] = headers.merge(options[:headers] || {})
+        
+        options
+      end
 
-      options[:headers] = headers.merge(options[:headers] || {})
-      
-      options
-    end
+      def resource_path(relative_path, options)
+        _resources_name = options[:resources_name] || self.resources_name
 
-    def resource_path(relative_path, options)
-      _resources_name = options[:resources_name] || self.resources_name
+        if Helpers.present?(_resources_name)
+          Helpers.present?(relative_path) ? "#{_resources_name}/#{relative_path}" : _resources_name
+        else
+          relative_path.to_s
+        end
+      end
 
-      if Helpers.present?(_resources_name)
-        Helpers.present?(relative_path) ? "#{_resources_name}/#{relative_path}" : _resources_name
-      else
-        relative_path.to_s
+      def strip_params(http_verb, data)
+        data ||= {}
+        
+        if [:get, :head, :delete].include?(http_verb)
+          [query_string(data), nil]
+        else
+          [query_string({}), data]
+        end
       end
+
     end
 
-    def strip_params(http_verb, data)
-      data ||= {}
-      
-      if [:get, :head, :delete].include?(http_verb)
-        [query_string(data), nil]
-      else
-        [query_string({}), data]
-      end
+    
+    include HttpMethods
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.extend(HttpMethods)
     end
 
   end

data/lib/smooth_operator/persistence.rb

@@ -6,35 +6,25 @@ module SmoothOperator
       base.extend(ClassMethods)
     end
 
-    module ClassMethods
-
-      def methods_vs_http_verbs
-        @methods_vs_http_verbs ||= { reload: :get, create: :post, update: :put, destroy: :delete }
-      end
+    attr_reader :last_remote_call
 
-      [:reload, :create, :update, :destroy].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
 
+    def get_identificator
+      get_internal_data(self.class.identificator)
     end
 
-
     def reload(relative_path = nil, data = {}, options = {})
-      raise 'UnknownPath' if Helpers.blank?(relative_path) && (!respond_to?(:id) || Helpers.blank?(id))
+      raise 'UnknownPath' if Helpers.blank?(relative_path) && (!respond_to?(self.class.identificator) || Helpers.blank?(get_identificator))
 
-      make_the_call(*persistent_method_args(:reload, relative_path, data, options)) do |remote_call|
+      persistence_call(:reload, relative_path, data, options) do |remote_call|
         block_given? ? yield(remote_call) : remote_call.status
       end
     end
 
-    def new_record?
-      return @new_record if defined?(@new_record)
+    def new_record?(bypass_cache = false)
+      return @new_record if !bypass_cache && defined?(@new_record)
 
-      @new_record = Helpers.blank?(get_internal_data("id"))
+      @new_record = Helpers.blank?(get_identificator)
     end
 
     def destroyed?
@@ -66,7 +56,7 @@ module SmoothOperator
     def destroy(relative_path = nil, data = {}, options = {})
       return false unless persisted?
 
-      make_the_call(*persistent_method_args(:destroy, relative_path, data, options)) do |remote_call|
+      persistence_call(:destroy, relative_path, data, options) do |remote_call|
         @destroyed = true if remote_call.status
 
         block_given? ? yield(remote_call) : remote_call.status
@@ -77,7 +67,7 @@ module SmoothOperator
     protected ######################### PROTECTED ##################
 
     def create(relative_path, data, options)
-      make_the_call(*persistent_method_args(:create, relative_path, data, options)) do |remote_call|
+      persistence_call(:create, relative_path, data, options) do |remote_call|
         @new_record = false if remote_call.status
 
         block_given? ? yield(remote_call) : remote_call
@@ -85,52 +75,25 @@ module SmoothOperator
     end
 
     def update(relative_path, data, options)
-      make_the_call(*persistent_method_args(:update, relative_path, data, options)) do |remote_call|
+      persistence_call(:update, relative_path, data, options) do |remote_call|
         block_given? ? yield(remote_call) : remote_call
       end
     end
 
-    def make_the_call(http_verb, relative_path, data, options)
-      self.class.make_the_call(http_verb, relative_path, data, options) do |remote_call|
-        @last_remote_call = remote_call
-
-        returning_data = @last_remote_call.parsed_response
-
-        if !@last_remote_call.error? && returning_data.is_a?(Hash)
-          assign_attributes returning_data, from_server: true
-        end
-
-        yield(remote_call)
-      end
-    end
-
-
-    private ##################### PRIVATE ####################
-
-    def persistent_method_args(method, relative_path, data, options)
+    def persistence_call(method, relative_path, data, options)
       options ||= {}
 
-      relative_path = resource_path(relative_path)
+      http_verb = options[:http_verb] || self.class.methods_vs_http_verbs[method]
 
-      if !parent_object.nil? && options[:ignore_parent] != true
-        options[:resources_name] ||= "#{parent_object.class.resources_name}/#{parent_object.id}/#{self.class.resources_name}"
-      end
+      make_the_call(http_verb, relative_path, data, options) do |remote_call|
+        @last_remote_call = remote_call
 
-      [http_verb_for(method, options), relative_path, data, options]
-    end
+        if !@last_remote_call.error? && @last_remote_call.parsed_response.is_a?(Hash)
+          assign_attributes @last_remote_call.parsed_response, from_server: true
+        end
 
-    def resource_path(relative_path)
-      relative_path = if Helpers.present?(relative_path) && relative_path[0] == '/'
-        relative_path[1..-1]
-      elsif persisted?
-        Helpers.present?(relative_path) ? "#{id}/#{relative_path}" : id.to_s
+        yield(remote_call)
       end
-
-      relative_path
-    end
-
-    def http_verb_for(method, options)
-      options[:http_verb] || self.class.methods_vs_http_verbs[method]
     end
 
     def data_with_object_attributes(data, options)
@@ -138,10 +101,35 @@ module SmoothOperator
 
       hash = serializable_hash(options[:serializable_options]).dup
 
-      hash.delete('id')
+      hash.delete(self.class.identificator)
 
       { 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 identificator
+        Helpers.get_instance_variable(self, :identificator, 'id')
+      end
+
+      attr_writer :identificator
+
+      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
 

data/lib/smooth_operator/version.rb

@@ -1,3 +1,3 @@
 module SmoothOperator
-  VERSION = "1.10.24"
+  VERSION = "1.11.1"
 end

data/spec/smooth_operator/persistence_spec.rb

@@ -109,16 +109,16 @@ shared_examples_for "a method that calls the #make_the_call method" do
 
   it "it should pass all arguments to #make_the_call" do
     _method_arguments = method_arguments.dup
-    _method_arguments[0] = _method_arguments[0][1..-1]
+    _method_arguments[0] = SmoothOperator::Helpers.remove_initial_slash(_method_arguments[0])
 
-    expect(subject).to receive(:make_the_call).with(:get, *_method_arguments)
+    expect(subject.class).to receive(:make_the_call).with(:get, *_method_arguments)
 
     execute_method
   end
 
   it "it should pass all arguments to .make_the_call" do
     _method_arguments = method_arguments.dup
-    _method_arguments[0] = _method_arguments[0][1..-1]
+    _method_arguments[0] = SmoothOperator::Helpers.remove_initial_slash(_method_arguments[0])
 
     expect(subject.class).to receive(:make_the_call).with(:get, *_method_arguments)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smooth_operator
 version: !ruby/object:Gem::Version
-  version: 1.10.24
+  version: 1.11.1
 platform: ruby
 authors:
 - João Gonçalves
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-21 00:00:00.000000000 Z
+date: 2014-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler