smooth_operator 1.8.8 → 1.9.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NDYzNDA5ZmU0YzkzNDFmMzEzMzkyMjk5OWY3YWIzZjUzZWJlZGI0ZA==
+    M2UzYWIwNGJhMGE3YTA4YTUyNjA5MzM2NzdkMTM1MzdjZWFmZjVlYg==
   data.tar.gz: !binary |-
-    ZGQ4ZTRhZjhlMzAyMWRlYTFiNDkwYzM1YTQwNzk1MTkxM2E1YzQ1Yw==
+    YTVjOTE5MWM3NmNkNjA3MWUyNmU5M2Y5YThjMDM1NzYwOTQyZjdkMw==
 SHA512:
   metadata.gz: !binary |-
-    MGQ3NDUyY2U5MzMwNGE5NGNiZDk1OWQ1ZjU2ZjM1NTA2ZGIzNTFlYzJkYWZm
-    Yjc5MDBhNDhhYThlZjkyYmE0NjcyZWQxYjczMGZiMDYzNTdjOGMwYTBkMWRm
-    MjE0MzdmODgzYjM3M2RhYTg4NmIxOTljNjBjOTg3YjQ2ZDUxZDQ=
+    N2YwN2Y3ODg3YzFhZDQxNjA1OWM4YTk3M2ExYTZkZWYxYjhkN2Y4N2M1ZTQw
+    NTllZTBhMGYxOGM3OTU4OTA4ZWUyMGIwNmY2YzM2NTZjNmQ2YmJiMzMwYjE1
+    MmQwYjgwOWI4ZjI5MjU1NTljNTg5MzY0ZWZjM2FiYzk5MDc3YWU=
   data.tar.gz: !binary |-
-    NjgxMmJkZTAzN2E5MjlkNzcxZmQyYmI5NDhmODM1OGFkYWIyZDA4YzYwNGQw
-    NDBmMzUyZDU4YjgwYzZlZGRmOWFmNGUwMjVjNDMwZmJiYTgwNDY4MWYxNTY3
-    NmE5MjZhNGYwMDBjMTliNjk0NGE1OTRlMjVlZDM2NjUzMDEzNzY=
+    M2I2NWVhZjExZGYzN2NkYTIwNjM5YWRjNGZlZDQ4Njk5MjNlZGI1YjQzM2U3
+    MmVlNWZkMWUyMDI1Y2ZhMGZmZWUwY2VjYjA2MzYyNWI0YjRmNDlkM2I1MWY4
+    YTVjZTRmZGM4NGY0YzdlNjBmMDAwOTg4YmNiMjFkMWFiYmYxMjA=

data/console.rb

@@ -5,7 +5,7 @@ $LOAD_PATH << './lib'
 
 require "spec/spec_helper"
 
-#User.post('', { user: { age: 1, posts: [{ body: 'post1' }, 2] } })
+#User::Base.post('', { user: { age: 1, posts: [{ body: 'post1' }, 2] } })
 
 binding.pry
 

data/lib/smooth_operator.rb

@@ -11,7 +11,7 @@ require "smooth_operator/finder_methods"
 
 module SmoothOperator
   
-  class Base < OpenStruct
+  class Base < OpenStruct::Base
 
     extend Operator
     extend FinderMethods

data/lib/smooth_operator/array_with_meta_data.rb

@@ -1,6 +1,6 @@
 module SmoothOperator
 
-  class ArrayWithMetaData < OpenStruct
+  class ArrayWithMetaData < OpenStruct::Base
     
     extend Forwardable
 

data/lib/smooth_operator/attribute_assignment.rb

@@ -1,4 +1,5 @@
-require 'smooth_operator/internal_attribute'
+require 'smooth_operator/attributes/base'
+require 'smooth_operator/attributes/dirty'
 
 module SmoothOperator
 
@@ -10,7 +11,11 @@ module SmoothOperator
 
     module ClassMethods
 
-      attr_accessor :turn_unknown_hash_to_open_struct
+      attr_writer :unknown_hash_class
+
+      def unknown_hash_class
+        Helpers.get_instance_variable(self, :unknown_hash_class, ::OpenStruct)
+      end
 
       def attributes_white_list
         Helpers.get_instance_variable(self, :attributes_white_list, Set.new)
@@ -28,6 +33,14 @@ module SmoothOperator
         attributes_black_list.merge getters.map(&:to_s)
       end
 
+      def dirty_attributes
+        @dirty_attributes = true
+      end
+
+      def dirty_attributes?
+        @dirty_attributes
+      end
+
     end
 
 
@@ -50,7 +63,15 @@ module SmoothOperator
     end
 
     def get_internal_data(field, method = :value)
-      internal_data[field].nil? ? nil : internal_data[field].send(method)
+      result = internal_data[field]
+
+      if result.nil?
+        nil
+      elsif method == :value
+        result.is_a?(Attributes::Dirty) ? internal_data[field].send(method) : internal_data[field]
+      else
+        internal_data[field].send(method)
+      end
     end
 
     def push_to_internal_data(attribute_name, attribute_value)
@@ -61,9 +82,9 @@ module SmoothOperator
       known_attributes.add attribute_name
       
       if internal_data[attribute_name].nil?
-        internal_data[attribute_name] = InternalAttribute.new(attribute_name, attribute_value, internal_structure[attribute_name], self.class.turn_unknown_hash_to_open_struct)
+        initiate_internal_data(attribute_name, attribute_value)
       else
-        internal_data[attribute_name].set_value(attribute_value)
+        update_internal_data(attribute_name, attribute_value)
       end
     end
 
@@ -84,6 +105,29 @@ module SmoothOperator
       end
     end
 
+
+    private ######################## PRIVATE #############################
+
+    def initiate_internal_data(attribute_name, attribute_value)
+      internal_data[attribute_name] = new_attribute_object(attribute_name, attribute_value)
+      
+      internal_data[attribute_name] = internal_data[attribute_name].value unless self.class.dirty_attributes?
+    end
+
+    def update_internal_data(attribute_name, attribute_value)
+      if self.class.dirty_attributes?
+        internal_data[attribute_name].set_value(attribute_value)
+      else
+        internal_data[attribute_name] = new_attribute_object(attribute_name, attribute_value)
+      end
+    end
+
+    def new_attribute_object(attribute_name, attribute_value)
+      attribute_class = self.class.dirty_attributes? ?  Attributes::Dirty : Attributes::Base
+      
+      attribute_class.new(attribute_name, attribute_value, internal_structure[attribute_name], self.class.unknown_hash_class)
+    end
+
   end
 
 end

data/lib/smooth_operator/attributes/base.rb

@@ -0,0 +1,17 @@
+require 'smooth_operator/type_converter'
+
+module SmoothOperator
+  module Attributes
+
+    class Base
+
+      attr_reader :value
+
+      def initialize(name, value, type, unknown_hash_class)
+        @value = TypeConverter.cast_to_type(name, value, type, self.class, unknown_hash_class)
+      end
+
+    end
+
+  end
+end

data/lib/smooth_operator/attributes/dirty.rb

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

data/lib/smooth_operator/helpers.rb

@@ -13,8 +13,12 @@ module SmoothOperator
 
       return instance_var unless instance_var.nil?
 
-      (super_method(object, variable) || default_value).dup.tap do |instance_var|
+      instance_var = (super_method(object, variable) || default_value)
+
+      if instance_var.class == Class
         object.instance_variable_set("@#{variable}", instance_var)
+      else
+        object.instance_variable_set("@#{variable}", duplicate(instance_var))
       end
     end
 

data/lib/smooth_operator/open_struct.rb

@@ -5,15 +5,23 @@ require "smooth_operator/serialization"
 require "smooth_operator/attribute_assignment"
 
 module SmoothOperator
+  module OpenStruct
 
-  class OpenStruct
+    class Base
 
-    include Delegation
-    include Validations
-    include ModelSchema
-    include Serialization
-    include AttributeAssignment
+      include Delegation
+      include Validations
+      include ModelSchema
+      include Serialization
+      include AttributeAssignment
 
-  end
+    end
+
+    class Dirty < Base
 
+      dirty_attributes
+      
+    end
+
+  end
 end

data/lib/smooth_operator/type_converter.rb

@@ -4,6 +4,17 @@ module SmoothOperator
 
     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
 
@@ -63,6 +74,30 @@ module SmoothOperator
 
       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
   

data/lib/smooth_operator/version.rb

@@ -1,3 +1,3 @@
 module SmoothOperator
-  VERSION = "1.8.8"
+  VERSION = "1.9.0"
 end

data/spec/factories/user_factory.rb

@@ -1,6 +1,6 @@
 FactoryGirl.define do
   
-  factory :user, class: User do
+  factory :user, class: User::Base do
     
     id 1
     admin true
@@ -20,12 +20,12 @@ FactoryGirl.define do
 
   end
 
-  factory :white_list, class: User do
+  factory :white_list, class: User::Base do
     id 1
     first_name 'John'
   end
   
-  factory :black_list, class: User do
+  factory :black_list, class: User::Base do
     admin true
     last_name 'Doe'
   end

data/spec/smooth_operator/attribute_assignment_spec.rb

@@ -34,28 +34,42 @@ describe SmoothOperator::AttributeAssignment do
     context "when something other than a hash is introduced" do
       it "should do nothing" do
         [nil, '', [1, 2], 'test', 1, 2].each do |something_other_than_a_hash|
-          expect(User.new(something_other_than_a_hash).internal_data).to eq({})
+          expect(User::Base.new(something_other_than_a_hash).internal_data).to eq({})
         end
       end
     end
 
     context "when one of the attribute's value, is an hash and is unknown to the schema" do
-      context "when the .turn_unknown_hash_to_open_struct is set to true or unused" do
-        subject { User.new(address: { street: 'something', postal_code: { code: '123' } }) }
+      context "when the .unknown_hash_class is unused" do
+        subject { User::Base.new(address: { street: 'something', postal_code: { code: '123' } }) }
 
-        it "a new instance of SmoothOperator::OpenStruct will be initialized with that hash" do
+        it "a new instance of OpenStruct will be initialized with that hash" do
           address = subject.address
 
-          expect(address).to be_instance_of(SmoothOperator::OpenStruct)
+          expect(address).to be_instance_of(OpenStruct)
           expect(address.street).to eq('something')
 
-          expect(address.postal_code).to be_instance_of(SmoothOperator::OpenStruct)
+          expect(address.postal_code).to be_instance_of(OpenStruct)
           expect(address.postal_code.code).to eq('123')
         end
       end
-        
-      context "when the .turn_unknown_hash_to_open_struct is set to false", current: true do
-        subject { Post.new(creator: { first_name: 'admin', address: { street: 'something' } }) }
+      
+      context "when the .unknown_hash_class is set to SmoothOperator::OpenStruct::Base" do
+        subject { User::UnknownHashClass::OpenStructBase.new(address: { street: 'something', postal_code: { code: '123' } }) }
+
+        it "a new instance of SmoothOperator::OpenStruct::Base will be initialized with that hash" do
+          address = subject.address
+
+          expect(address).to be_instance_of(SmoothOperator::OpenStruct::Base)
+          expect(address.street).to eq('something')
+
+          expect(address.postal_code).to be_instance_of(SmoothOperator::OpenStruct::Base)
+          expect(address.postal_code.code).to eq('123')
+        end
+      end
+
+      context "when the .unknown_hash_class is set to :none" do
+        subject { User::UnknownHashClass::None.new(creator: { first_name: 'admin', address: { street: 'something' } }) }
 
         it "the hash will be copied as it is" do
           creator = subject.creator
@@ -70,7 +84,7 @@ describe SmoothOperator::AttributeAssignment do
     end
 
     context "when there is no declared schema" do
-      subject { User.new(attributes_for(:user)) }
+      subject { User::Base.new(attributes_for(:user)) }
       let(:expected_internal_data) { SmoothOperator::Helpers.stringify_keys(attributes_for(:user)) }
 
       it "it should populate 'internal_data' with unaltered duplicate data from the received hash" do

data/spec/smooth_operator/attributes_dirty_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe SmoothOperator::Attributes::Dirty do
+
+  subject { UserWithAddressAndPosts::DirtyAttributes.new(attributes_for(:user_with_address_and_posts)) }
+
+  context "when no changes are made to an attribute" do
+    it "checking if that attribute is changed, should return false" do
+      expect(subject.first_name_changed?).to be false
+    end
+
+    it "checking that attribute past value, should its original value" do
+      expect(subject.first_name_was).to eq('John')
+    end
+  end
+
+  context "when there are changes made to an attribute" do
+    before { subject.first_name = 'nhoJ' }
+
+    it "checking if that attribute is changed, should return true" do
+      expect(subject.first_name_changed?).to be true
+    end
+
+    it "checking that attribute past value, should its original value" do
+      expect(subject.first_name_was).to eq('John')
+    end
+
+    context "when there are changes to the changes made to an attribute" do
+      before { subject.first_name = 'no_name' }
+
+      it "checking if that attribute is changed, should return true" do
+        expect(subject.first_name_changed?).to be true
+      end
+
+      it "checking that attribute past value, should its first original value" do
+        expect(subject.first_name_was).to eq('John')
+      end
+    end
+  end
+
+  context "when there are changes made to a nested object" do
+    before { subject.address.street = 'my street' }
+
+    it "checking if the nested object as changed, should return false" do
+      expect(subject.address_changed?).to be false
+    end
+
+    it "checking if the nested object's attribute as changed, should return true" do
+      expect(subject.address.street_changed?).to be true
+    end
+  end
+
+end

data/spec/smooth_operator/delegation_spec.rb

@@ -45,7 +45,7 @@ describe SmoothOperator::Delegation do
   describe "#method_missing" do
     
     context "when calling a method that matches the initialized attributes" do
-      subject { User.new(attributes_for(:user)) }
+      subject { User::Base.new(attributes_for(:user)) }
 
       it 'it should return the value of that same attribute' do
         attributes_for(:user).each do |key, value|
@@ -85,52 +85,6 @@ describe SmoothOperator::Delegation do
       end
     end
 
-    context "when no changes are made to an attribute" do
-      it "checking it that attribute is changed, should return false" do
-        expect(subject.first_name_changed?).to be false
-      end
-
-      it "checking that attribute past value, should its original value" do
-        expect(subject.first_name_was).to eq('John')
-      end
-    end
-
-    context "when there are changes made to an attribute" do
-      before { subject.first_name = 'nhoJ' }
-
-      it "checking if that attribute is changed, should return true" do
-        expect(subject.first_name_changed?).to be true
-      end
-
-      it "checking that attribute past value, should its original value" do
-        expect(subject.first_name_was).to eq('John')
-      end
-
-      context "when there are changes to the changes made to an attribute" do
-        before { subject.first_name = 'no_name' }
-
-        it "checking it that attribute is changed, should return true" do
-          expect(subject.first_name_changed?).to be true
-        end
-
-        it "checking that attribute past value, should its first original value" do
-          expect(subject.first_name_was).to eq('John')
-        end
-      end
-    end
-
-    context "when there are changes made to a nested object" do
-      before { subject.address.street = 'my street' }
-
-      it "checking if the nested object as changed, should return false" do
-        expect(subject.address_changed?).to be false
-      end
-
-      it "checking if the nested object's attribute as changed, should return true" do
-        expect(subject.address.street_changed?).to be true
-      end
-    end
-
   end
 
 end

data/spec/smooth_operator/model_schema_spec.rb

@@ -6,7 +6,7 @@ describe SmoothOperator::ModelSchema do
     let(:initial_attributes_keys) { attributes_for(:user).keys.map(&:to_s) }
 
     context "when there is no declared schema" do
-      subject { User.new(attributes_for(:user)) }
+      subject { User::Base.new(attributes_for(:user)) }
 
       it 'it should reflect the attributes used uppon initialization' do
         expect(subject.known_attributes.to_a).to match_array(initial_attributes_keys)

data/spec/smooth_operator/operator_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 
 describe SmoothOperator::Operator do
-  subject { User }
+  subject { User::Base }
 
   describe "#get" do
 

data/spec/smooth_operator/validations_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 
 describe SmoothOperator::Validations do
-  subject { User.new(attributes_for(:user)) }
+  subject { User::Base.new(attributes_for(:user)) }
 
   describe "#valid?" do
     context "when executing a persistence method, and the server response has a hash with the key 'errors'" do

data/spec/support/models/address.rb

@@ -1,4 +1,7 @@
 class Address < SmoothOperator::Base
+
+  self.dirty_attributes
+
   self.model_name = :none
 
   self.endpoint_user = 'admin'
@@ -7,4 +10,5 @@ class Address < SmoothOperator::Base
   self.endpoint = 'http://localhost:4567/'
 
   self.headers = { "X-APPTOKEN" => "joaquim_app_token", "X-LAYERTOKEN" => "joaquim_layer_token" }
+  
 end

data/spec/support/models/post.rb

@@ -1,6 +1,4 @@
 class Post < SmoothOperator::Base
-
-  self.turn_unknown_hash_to_open_struct = false
   
   self.endpoint = 'http://localhost:3000/api/v0'
 

data/spec/support/models/user.rb

@@ -1,15 +1,33 @@
-class User < SmoothOperator::Base
+module User
+  
+  class Base < SmoothOperator::Base
 
-  self.endpoint_user = 'admin'
+    self.model_name = 'user'
 
-  self.endpoint_pass = 'admin'
+    self.endpoint_user = 'admin'
 
-  self.endpoint = 'http://localhost:4567/'
+    self.endpoint_pass = 'admin'
 
-  def self.query_string(params)
-    params['query_string_param'] = true
+    self.endpoint = 'http://localhost:4567/'
+
+    def self.query_string(params)
+      params['query_string_param'] = true
+
+      params
+    end
+
+  end
+
+  module UnknownHashClass
+    
+    class OpenStructBase < User::Base
+      self.unknown_hash_class = SmoothOperator::OpenStruct::Base
+    end
+
+    class None < User::Base
+      self.unknown_hash_class = :none
+    end
 
-    params
   end
 
 end

data/spec/support/models/user_with_address_and_posts.rb

@@ -1,6 +1,6 @@
 module UserWithAddressAndPosts
   
-  class Father < User
+  class Father < User::Base
 
     schema(
       posts: Post,
@@ -70,4 +70,12 @@ module UserWithAddressAndPosts
 
   end
 
+  class DirtyAttributes < UserWithAddressAndPosts::Son
+
+    self.dirty_attributes
+
+    self.unknown_hash_class = SmoothOperator::OpenStruct::Dirty
+
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smooth_operator
 version: !ruby/object:Gem::Version
-  version: 1.8.8
+  version: 1.9.0
 platform: ruby
 authors:
 - João Gonçalves
@@ -69,10 +69,11 @@ files:
 - lib/smooth_operator.rb
 - lib/smooth_operator/array_with_meta_data.rb
 - lib/smooth_operator/attribute_assignment.rb
+- lib/smooth_operator/attributes/base.rb
+- lib/smooth_operator/attributes/dirty.rb
 - lib/smooth_operator/delegation.rb
 - lib/smooth_operator/finder_methods.rb
 - lib/smooth_operator/helpers.rb
-- lib/smooth_operator/internal_attribute.rb
 - lib/smooth_operator/model_schema.rb
 - lib/smooth_operator/open_struct.rb
 - lib/smooth_operator/operator.rb
@@ -86,6 +87,7 @@ files:
 - smooth_operator.gemspec
 - spec/factories/user_factory.rb
 - spec/smooth_operator/attribute_assignment_spec.rb
+- spec/smooth_operator/attributes_dirty_spec.rb
 - spec/smooth_operator/delegation_spec.rb
 - spec/smooth_operator/finder_methods_spec.rb
 - spec/smooth_operator/model_schema_spec.rb
@@ -130,6 +132,7 @@ summary: Simple and fully customizable alternative to ActiveResource, using fara
 test_files:
 - spec/factories/user_factory.rb
 - spec/smooth_operator/attribute_assignment_spec.rb
+- spec/smooth_operator/attributes_dirty_spec.rb
 - spec/smooth_operator/delegation_spec.rb
 - spec/smooth_operator/finder_methods_spec.rb
 - spec/smooth_operator/model_schema_spec.rb

data/lib/smooth_operator/internal_attribute.rb

@@ -1,49 +0,0 @@
-require 'smooth_operator/type_converter'
-
-module SmoothOperator
-
-  class InternalAttribute
-
-    attr_reader :original_name, :original_value, :first_value, :value, :type, :turn_unknown_hash_to_open_struct
-
-    def initialize(name, value, type, turn_to_open_struct = nil)
-      @original_name, @original_value, @type = name, value, type
-      
-      @turn_unknown_hash_to_open_struct = turn_to_open_struct.nil? ? true : turn_to_open_struct
-
-      @first_value = set_value(value)
-    end
-
-    def set_value(new_value)
-      @value = cast_to_type(new_value)
-    end
-
-    def changed?
-      @first_value != @value
-    end
-
-    def was
-      @first_value
-    end
-
-
-    protected ######################## PROTECTED #####################
-
-    def cast_to_type(_value)
-      case _value
-      when Array
-        _value.map { |array_entry| InternalAttribute.new(original_name, array_entry, type, turn_unknown_hash_to_open_struct).value }
-      when Hash
-        if turn_unknown_hash_to_open_struct
-          (type || OpenStruct).new(_value)
-        else
-          type.nil? ? _value : type.new(_value)
-        end
-      else
-        TypeConverter.convert(_value, type)
-      end
-    end
-
-  end
-
-end