smooth_operator 1.10.6 → 1.10.9

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MjFkNjcxMjZmMWFkYzYzY2E1NWE3ZDA5ODdkYzJmYTkwMWZhZTExOA==
+    NTYxNDdmNGJiNTIzZWU5YTc2MzlmYTkzYTJjOTZjOTcyZWU5YjMwMg==
   data.tar.gz: !binary |-
-    ODBjZTE5NzQwNDU0MmQwY2M0MGQ1ZWZmM2VhNmM0YThmNDQ4Y2U3MA==
+    YjlhYzNiNWUwNDdiYjUyOTMyNDY2YjhmYmM3YmE0YzNlM2I2MTBjZQ==
 SHA512:
   metadata.gz: !binary |-
-    NDc2OTA2NWFkZTBkN2I5Y2FiNGEwNDQ2YTAyNTg0NDc4ZDYxYWMwYTk2Y2Y3
-    YzY3ZTVlZDUwNjNlNDEzMjc3NGM4YThjODZkYjNiYTZmY2EzYTA4MzMxYjg0
-    MDQxM2Y4ZDA0NGRmNTUwNjRhOTExZWQ4YjY5NDhiZDhkYzllNzk=
+    NTQwNzAxYTExZDA0ZjE3YWMwNDJhMDljZjRkMWU3OTFlNzgzNWU4ODliN2Ez
+    MzI2NjUyZDMyYjdlYjJmYThkOGUzN2NlYjkxMTc1ODNiMGUyNmJiNzdkMjdl
+    OTVhYjAwNDlhZTliNDA4ODE1ODM1NWY5NzIwYTExN2MyOWZjNTQ=
   data.tar.gz: !binary |-
-    MzMyODcyNTZhZDY1MzE3MWUzNDg1NjI0NzRmODEyN2NiMWViMmNhZTdkZmQ3
-    M2EzOTlhZmZkMjQ5ZDkyYjAzODIyYmQ5MzM3NTQ2ZGM2YmRiMzlmZGJhZTll
-    ZWNhMDBmMGNlYjA3NTFlNGU2ZjAyYmE3YjQ4NWY1ZmM1YzgxZGM=
+    YTc1ODM3MmZlNmFjOGM0ZjYzNjc3ZTA0MmE1NGRlNzkyOWQzM2NiNmM5MTc2
+    YjE0ZDg5YjcxNWY1ODk4ODE5ZjNkZWMyOWVmNWZlNzE5MTRiMTdmOTY1MmYz
+    MTVlMDBhZGQyNjg1ZDNjMGJjM2I1YmE4MmY5OWFkZGNiNDg2Zjk=

data/lib/smooth_operator/array_with_meta_data.rb

@@ -10,10 +10,11 @@ module SmoothOperator
 
     def_delegators :internal_array, :length, :<<, :[]
 
-    def initialize(attributes, table_name, object_class)
+    def initialize(attributes, object_class)
       _attributes = attributes.dup
 
-      @table_name, @object_class = table_name, object_class
+      @object_class = object_class
+      @table_name = object_class.table_name
 
       @internal_array = [*_attributes[table_name]].map { |array_entry| object_class.new(array_entry).tap { |object| object.reloaded = true } }
       _attributes.delete(table_name)

data/lib/smooth_operator/attribute_assignment.rb

@@ -1,5 +1,6 @@
 require 'smooth_operator/attributes/base'
 require 'smooth_operator/attributes/dirty'
+require 'smooth_operator/attributes/normal'
 
 module SmoothOperator
 
@@ -44,20 +45,44 @@ module SmoothOperator
     end
 
 
-    def initialize(attributes = {})
-      before_initialize(attributes)
+    def initialize(attributes = {}, options = {})
+      @_options = {}
 
-      assign_attributes attributes
+      before_initialize(attributes, options)
 
-      after_initialize(attributes)
+      assign_attributes attributes, options
+
+      after_initialize(attributes, options)
     end
 
-    def assign_attributes(attributes = {})
-      return nil unless attributes.is_a?(Hash)
+    attr_reader :_options, :_meta_data
+
+
+    def assign_attributes(_attributes = {}, options = {})
+      return nil unless _attributes.is_a?(Hash)
+      
+      attributes = _attributes = Helpers.stringify_keys(_attributes)
+
+      if _attributes.include?(model_name)
+        attributes = _attributes.delete(model_name)
+        @_meta_data = _attributes
+      end
       
+      options.each { |key, value| @_options[key] = value } if options.is_a?(Hash)
+
       attributes.each { |name, value| push_to_internal_data(name, value) }
     end
 
+    def parent_object
+      _options[:parent_object]
+    end
+
+    def has_data_from_server
+      _options[:from_server] == true
+    end
+
+    alias :from_server :has_data_from_server
+
     def internal_data
       @internal_data ||= {}
     end
@@ -91,9 +116,9 @@ module SmoothOperator
     
     protected #################### PROTECTED METHODS DOWN BELOW ######################
 
-    def before_initialize(attributes); end
+    def before_initialize(attributes, options); end
 
-    def after_initialize(attributes); end
+    def after_initialize(attributes, options); end
 
     def allowed_attribute(attribute)
       if !self.class.attributes_white_list.empty?
@@ -116,16 +141,16 @@ module SmoothOperator
 
     def update_internal_data(attribute_name, attribute_value)
       if self.class.dirty_attributes?
-        internal_data[attribute_name].set_value(attribute_value)
+        internal_data[attribute_name].set_value(attribute_value, self.class.unknown_hash_class, self)
       else
         internal_data[attribute_name] = new_attribute_object(attribute_name, attribute_value).value
       end
     end
 
     def new_attribute_object(attribute_name, attribute_value)
-      attribute_class = self.class.dirty_attributes? ?  Attributes::Dirty : Attributes::Base
+      attribute_class = self.class.dirty_attributes? ?  Attributes::Dirty : Attributes::Normal
       
-      attribute_class.new(attribute_name, attribute_value, internal_structure[attribute_name], self.class.unknown_hash_class)
+      attribute_class.new(attribute_name, attribute_value, internal_structure[attribute_name], self.class.unknown_hash_class, self)
     end
 
   end

data/lib/smooth_operator/attributes/base.rb

@@ -1,14 +1,100 @@
-require 'smooth_operator/type_converter'
-
 module SmoothOperator
   module Attributes
 
     class Base
 
-      attr_reader :value
+      protected ##################### PROTECTED ########################
+
+      def cast_to_type(name, value, type, unknown_hash_class, parent_object)
+        case value
+        when Array
+          value.map { |array_entry| self.class.new(name, array_entry, type, unknown_hash_class, parent_object).value }
+        when Hash
+          type.nil? ? new_unknown_hash(value, unknown_hash_class, parent_object) : type.new(value, parent_object: parent_object)
+        else
+          convert(value, type)
+        end
+      end
+
+      def convert(value, type)
+        case type
+
+        when :string, :text, String
+          value.to_s
+        
+        when :int, :integer, Integer, Fixnum
+          to_int(value)
+
+        when :date, Date
+          to_date(value)
+
+        when :float, Float
+          to_float(value)
+
+        when :bool, :boolean
+          to_boolean(value)
+
+        when :datetime, :date_time, DateTime
+          to_datetime(value)
+
+        else
+          Helpers.duplicate(value)
+        end
+      end
+
+      def to_int(string)
+        return string if string.is_a?(Fixnum)
+
+        to_float(string).to_i
+      end
+
+      def to_date(string)
+        return string if string.is_a?(Date)
+
+        Date.parse(string) rescue nil
+      end
+
+      def to_datetime(string)
+        return string if string.is_a?(DateTime)
+
+        DateTime.parse(string) rescue nil
+      end
+
+      def to_boolean(string)
+        value = string.to_s.downcase
+
+        ['1', 'true'].include?(value) ? true : ['0', 'false'].include?(value) ? false : nil
+      end
+
+      def to_float(string)
+        return string if string.is_a?(Float)
+
+        return 0 if string.nil? || !string.is_a?(String)
+        
+        value = string.scan(/-*\d+[,.]*\d*/).flatten.map(&:to_f).first
+
+        value.nil? ? 0 : value
+      end
+
+      def new_unknown_hash(hash, unknown_hash_class, parent_object)
+        if unknown_hash_class == :none
+          hash
+        else
+          unknown_hash_class.new(cast_params(hash, unknown_hash_class, parent_object))
+        end
+      end
+
+
+      private ################### PRIVATE #####################
+
+      def cast_params(attributes, unknown_hash_class, parent_object)
+        hash = {}
+
+        attributes.each do |key, value|
+          hash[key] = cast_to_type(key, value, nil, unknown_hash_class, parent_object)
+        end
 
-      def initialize(name, value, type, unknown_hash_class)
-        @value = TypeConverter.cast_to_type(name, value, type, self.class, unknown_hash_class)
+        hash
       end
 
     end

data/lib/smooth_operator/attributes/dirty.rb

@@ -1,20 +1,18 @@
-require 'smooth_operator/type_converter'
-
 module SmoothOperator
   module Attributes
 
-    class Dirty
+    class Dirty < Base
 
-      attr_reader :original_name, :original_value, :first_value, :value, :type, :unknown_hash_class
+      attr_reader :original_name, :original_value, :first_value, :value, :type
 
-      def initialize(name, value, type, unknown_hash_class)
-        @original_name, @original_value, @type, @unknown_hash_class = name, value, type, unknown_hash_class
+      def initialize(name, value, type, unknown_hash_class, parent_object)
+        @original_name, @original_value, @type = name, value, type
 
-        @first_value = set_value(value)
+        @first_value = set_value(value, unknown_hash_class, parent_object)
       end
 
-      def set_value(new_value)
-        @value = TypeConverter.cast_to_type(original_name, new_value, type, self.class, unknown_hash_class)
+      def set_value(new_value, unknown_hash_class, parent_object)
+        @value = cast_to_type(original_name, new_value, type, unknown_hash_class, parent_object)
       end
 
       def changed?

data/lib/smooth_operator/attributes/normal.rb

@@ -0,0 +1,15 @@
+module SmoothOperator
+  module Attributes
+
+    class Normal < Base
+
+      attr_reader :value
+
+      def initialize(name, value, type, unknown_hash_class, parent_object)
+        @value = cast_to_type(name, value, type, unknown_hash_class, parent_object)
+      end
+
+    end
+
+  end
+end

data/lib/smooth_operator/finder_methods.rb

@@ -27,13 +27,15 @@ module SmoothOperator
 
     def build_object(parsed_response, options)
       options ||={}
-      
-      table_name = (options[:table_name] || self.table_name).to_s
 
       if parsed_response.is_a?(Array)
         parsed_response.map { |array_entry| build_object(array_entry, options) }
       elsif parsed_response.is_a?(Hash)
-        parsed_response.include?(table_name) ? ArrayWithMetaData.new(parsed_response, table_name, self) : new(parsed_response).tap { |object| object.reloaded = true }
+        if parsed_response.include?(table_name)
+          ArrayWithMetaData.new(parsed_response, self)
+        else
+          new(parsed_response, from_server: true)
+        end
       else
         parsed_response
       end

data/lib/smooth_operator/operators/faraday.rb

@@ -12,14 +12,7 @@ module SmoothOperator
         remote_call = begin
           set_basic_authentication
 
-          response = connection.send(http_verb) do |request|
-            operator_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.url relative_path
-            request.body = body
-          end
+          response = connection.send(http_verb, relative_path) { |request| request_configuration(request) }
 
           RemoteCall::Faraday.new(response)
         rescue ::Faraday::Error::ConnectionFailed
@@ -40,6 +33,16 @@ module SmoothOperator
         connection.basic_auth(endpoint_user, endpoint_pass) if Helpers.present?(endpoint_user)
       end
 
+      def request_configuration(request)
+        operator_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
+      end
+
     end
 
   end

data/lib/smooth_operator/persistence.rb

@@ -27,10 +27,13 @@ module SmoothOperator
     end
 
 
-    attr_accessor :extra_params, :reloaded, :meta_data
+    attr_accessor :extra_params
 
     def reload(relative_path = nil, data = {}, options = {})
-      relative_path = id.to_s if Helpers.blank?(relative_path)
+      raise 'UnknownPath' if !respond_to?(:id) || Helpers.blank?(id)
+
+      relative_path, options = build_relative_path(relative_path, options)
+
       success = {}
 
       make_remote_call(:get, relative_path, data, options) do |remote_call|
@@ -52,12 +55,6 @@ module SmoothOperator
       @destroyed = false
     end
 
-    def reloaded?
-      return @reloaded if defined?(@reloaded)
-
-      @reloaded = false
-    end
-
     def persisted?
       !(new_record? || destroyed?)
     end
@@ -73,7 +70,7 @@ module SmoothOperator
     def destroy(relative_path = nil, data = {}, options = {})
       return false unless persisted?
 
-      relative_path = id.to_s if Helpers.blank?(relative_path)
+      relative_path, options = build_relative_path(relative_path, options)
 
       success = {}
 
@@ -106,7 +103,7 @@ module SmoothOperator
     end
 
     def update(relative_path, data, options)
-      relative_path = id.to_s if Helpers.blank?(relative_path)
+      relative_path, options = build_relative_path(relative_path, options)
       
       success = {}
 
@@ -120,6 +117,24 @@ module SmoothOperator
 
     private ##################### PRIVATE ####################
 
+    def build_relative_path(relative_path, options)
+      if Helpers.blank?(relative_path)
+        if parent_object.nil?
+          relative_path = id.to_s
+        else
+          options ||= {}
+          options[:table_name] = ''
+          relative_path = "#{parent_object.send(:rest_relative_path)}/#{table_name}/#{id}"
+        end
+      end
+
+      [relative_path, options]
+    end
+
+    def rest_relative_path
+      "#{table_name}/#{id}"
+    end
+
     def make_remote_call(http_verb, relative_path, data, options)
       data ||= {}
       data.merge!(extra_params || {})
@@ -132,16 +147,7 @@ module SmoothOperator
         returning_data = @last_remote_call.parsed_response
 
         if !@last_remote_call.error? && returning_data.is_a?(Hash)
-          @reloaded = true
-
-          attributes = returning_data
-
-          if returning_data.include?(model_name)
-            attributes = returning_data.delete(model_name)
-            @meta_data = returning_data
-          end
-
-          assign_attributes attributes
+          assign_attributes returning_data, from_server: true
         end
 
         yield(remote_call)

data/lib/smooth_operator/version.rb

@@ -1,3 +1,3 @@
 module SmoothOperator
-  VERSION = "1.10.6"
+  VERSION = "1.10.9"
 end

data/spec/smooth_operator/attribute_assignment_spec.rb

@@ -4,6 +4,36 @@ require "spec_helper"
 describe SmoothOperator::AttributeAssignment do
 
   describe "#assign_attributes" do
+    
+    describe "receiving data from server" do
+      subject { User::Base.new }
+
+      context "when receiving the option 'from_server = true'" do
+        before { subject.assign_attributes({}, from_server: true) }
+
+        it "#has_data_from_server and #from_server should return true" do
+          expect(subject.has_data_from_server).to be true
+          expect(subject.from_server).to be true
+        end
+      end
+
+      context "when receiving a Hash with meta_data on it" do
+        before { subject.assign_attributes({ user: attributes_for(:user), status: 1 }) }
+
+        it "#meta_data should reflect the receiving meta_data" do
+          expect(subject._meta_data).to eq({ "status" => 1 })
+        end
+
+        it "subject should NOT contain meta_data" do
+          expect{ subject.status }.to raise_error NoMethodError
+        end
+
+        it "subject should contain all other data" do
+          expect(subject.attributes).to eq(attributes_for(:user))
+        end
+      end
+
+    end
 
     describe "white and black list" do
       subject { UserWithAddressAndPosts::Son.new(attributes_for(:user_with_address_and_posts)) }

data/spec/smooth_operator/finder_methods_spec.rb

@@ -1,5 +1,20 @@
 require "spec_helper"
 
+shared_examples_for "finder method" do
+  it "it should return a RemoteCall instance with a subject's class instance" do
+    expect(user).to be_instance_of(subject)
+  end
+
+  it "the instance class should be populated with the returned hash" do
+    expect(user.attributes).to eq(attributes_for(:user_with_address_and_posts))
+  end
+
+  it "#has_data_from_server and #from_server should return true" do
+    expect(user.has_data_from_server).to be true
+    expect(user.from_server).to be true
+  end
+end
+
 describe SmoothOperator::FinderMethods do
   subject { UserWithAddressAndPosts::Son }
 
@@ -11,12 +26,22 @@ describe SmoothOperator::FinderMethods do
 
   describe ".find" do
     context "when the server returns a single hash" do
-      it "it should return a RemoteCall instance with a subject's class instance populated with the returned hash" do
-        remote_call = subject.find(5)
-        user = remote_call.object
+      let(:user) { subject.find(5).object }
+
+      it_behaves_like "finder method"
+    end
+
+    context "when the server returns a hash with meta_data" do
+      let(:user) { subject.find("5/with_metadata").object }
+
+      it_behaves_like "finder method"
+
+      it "#meta_data should reflect the receiving meta_data" do
+        expect(user._meta_data).to eq({ "status" => 1 })
+      end
 
-        expect(user).to be_instance_of(subject)
-        expect(user.attributes).to eq(attributes_for(:user_with_address_and_posts))
+      it "user should NOT contain meta_data" do
+        expect{ user.status }.to raise_error NoMethodError
       end
     end
 

data/spec/smooth_operator/persistence_spec.rb

@@ -90,6 +90,52 @@ end
 
 describe SmoothOperator::Persistence, helpers: :persistence do
 
+  describe "#reload", current: true do
+    subject { new_user }
+
+    context "before calling #reload" do
+      it "#has_data_from_server and #from_server should return false" do
+        expect(subject.from_server).to be_falsey
+        expect(subject.has_data_from_server).to be_falsey
+      end
+    end
+
+    context "when subject doesn't has an id" do
+      it "it should raise 'UnknownPath'" do
+        expect{ subject.reload }.to raise_error 'UnknownPath'
+      end
+    end
+
+    context "when subject has an id" do
+      before do
+        subject.id = 1
+        subject.reload
+      end
+
+      it "it should fetch server data" do
+        expect(subject.attributes).to eq(attributes_for(:user_with_address_and_posts))
+      end
+
+      it "#has_data_from_server and #from_server should return true" do
+        expect(subject.from_server).to be true
+        expect(subject.has_data_from_server).to be true
+      end
+    end
+
+    context "when calling #reload on a nested object" do
+      before do
+        subject.id = 1
+        subject.reload
+        subject.posts.first.reload
+      end
+
+      it "it should fetch server data, with the correct nested REST url" do
+        # binding.pry
+        expect(subject.posts.first.attributes).to eq({ id: 1, body: 'from_server' })
+      end
+    end
+  end
+
   describe ".create" do
     
     subject { created_subject }

data/spec/support/test_server.rb

@@ -9,8 +9,8 @@ class TestServer < Sinatra::Base
   end
 
   
-  get '/posts/:id' do
-    post_data = { id: 1, body: 'test' }
+  get '/users/:id/posts/:id' do
+    post_data = { id: 1, body: 'from_server' }
     json post_data
   end
 
@@ -54,8 +54,14 @@ class TestServer < Sinatra::Base
     json FactoryGirl.attributes_for(:user_with_address_and_posts)
   end
 
+  get '/users/:id/with_metadata' do
+    user_data = { user: FactoryGirl.attributes_for(:user_with_address_and_posts), status: 1 }
+    json user_data
+  end
+  
+
   put '/users/send_error' do
-    data_with_error = { id: 1, errors: { first_name: ["can't be blank"] } }
+    data_with_error = { id: 1, errors: [{ first_name: ["can't be blank"] }] }
     json data_with_error
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smooth_operator
 version: !ruby/object:Gem::Version
-  version: 1.10.6
+  version: 1.10.9
 platform: ruby
 authors:
 - João Gonçalves
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-07 00:00:00.000000000 Z
+date: 2014-05-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -85,6 +85,7 @@ files:
 - lib/smooth_operator/attribute_assignment.rb
 - lib/smooth_operator/attributes/base.rb
 - lib/smooth_operator/attributes/dirty.rb
+- lib/smooth_operator/attributes/normal.rb
 - lib/smooth_operator/delegation.rb
 - lib/smooth_operator/finder_methods.rb
 - lib/smooth_operator/helpers.rb
@@ -102,7 +103,6 @@ files:
 - lib/smooth_operator/remote_call/typhoeus.rb
 - lib/smooth_operator/serialization.rb
 - lib/smooth_operator/translation.rb
-- lib/smooth_operator/type_converter.rb
 - lib/smooth_operator/validations.rb
 - lib/smooth_operator/version.rb
 - smooth_operator.gemspec

data/lib/smooth_operator/type_converter.rb

@@ -1,104 +0,0 @@
-module SmoothOperator
-
-  module TypeConverter
-
-    extend self
-
-    def cast_to_type(name, value, type, array_class, unknown_hash_class)
-      case value
-      when Array
-        value.map { |array_entry| array_class.new(name, array_entry, type, unknown_hash_class).value }
-      when Hash
-        type.nil? ? new_unknown_hash(value, array_class, unknown_hash_class) : type.new(value)
-      else
-        TypeConverter.convert(value, type)
-      end
-    end
-
-    def convert(value, type)
-      case type
-
-      when :string, :text, String
-        value.to_s
-      
-      when :int, :integer, Integer, Fixnum
-        to_int(value)
-
-      when :date, Date
-        to_date(value)
-
-      when :float, Float
-        to_float(value)
-
-      when :bool, :boolean
-        to_boolean(value)
-
-      when :datetime, :date_time, DateTime
-        to_datetime(value)
-
-      else
-        Helpers.duplicate(value)
-      end
-    end
-
-    def to_int(string)
-      return string if string.is_a?(Fixnum)
-
-      to_float(string).to_i
-    end
-
-    def to_date(string)
-      return string if string.is_a?(Date)
-
-      Date.parse(string) rescue nil
-    end
-
-    def to_datetime(string)
-      return string if string.is_a?(DateTime)
-
-      DateTime.parse(string) rescue nil
-    end
-
-    def to_boolean(string)
-      value = string.to_s.downcase
-
-      ['1', 'true'].include?(value) ? true : ['0', 'false'].include?(value) ? false : nil
-    end
-
-    def to_float(string)
-      return string if string.is_a?(Float)
-
-      return 0 if string.nil? || !string.is_a?(String)
-      
-      value = string.scan(/-*\d+[,.]*\d*/).flatten.map(&:to_f).first
-
-      value.nil? ? 0 : value
-    end
-
-
-    protected ################### PROTECTED #####################
-
-    def new_unknown_hash(hash, array_class, unknown_hash_class)
-      if unknown_hash_class == :none
-        hash
-      else
-        unknown_hash_class.new(cast_params(hash, array_class, unknown_hash_class))
-      end
-    end
-
-
-    private ################### PRIVATE #####################
-
-    def cast_params(attributes, array_class, unknown_hash_class)
-      hash = {}
-
-      attributes.each do |key, value|
-        hash[key] = cast_to_type(key, value, nil, array_class, unknown_hash_class)
-      end
-
-      hash
-    end
-  
-  end
-  
-end