smooth_operator 1.20.10 → 1.21.0

data/lib/smooth_operator/type_casting.rb

@@ -0,0 +1,127 @@
+module SmoothOperator
+  module TypeCasting
+
+    # RIPPED FROM RAILS
+    TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE', 'on', 'ON'].to_set
+    FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off', 'OFF'].to_set
+
+    extend self
+
+    def cast_to_type(name, value, parent_object)
+      type, known_attribute, unknown_hash_class = extract_args(parent_object.class, name)
+
+      return Helpers.duplicate(value) if known_attribute && type.nil?
+
+      case value
+      when Array
+        value.map { |array_entry| cast_to_type(name, array_entry, parent_object) }
+      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
+
+    protected ##################### PROTECTED ########################
+
+    def extract_args(parent_object_class, name)
+      known_attribute, attribute_type = false, false
+
+      if parent_object_class.respond_to?(:known_attribute?)
+        known_attribute = parent_object_class.known_attribute?(name)
+      end
+
+      if parent_object_class.respond_to?(:attribute_type)
+        attribute_type = parent_object_class.attribute_type(name)
+      end
+
+      [
+        attribute_type,
+        known_attribute,
+        parent_object_class.unknown_hash_class
+      ]
+    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_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
+
+      TRUE_VALUES.include?(value) ? true : FALSE_VALUES.include?(value) ? false : nil
+    end
+
+    def to_int(string)
+      return string if string.is_a?(Fixnum)
+
+      to_float(string).to_i
+    end
+
+    def to_float(string)
+      return string if string.is_a?(Float)
+
+      return 0 if string.nil? || !(string.is_a?(String) || string.is_a?(Fixnum))
+
+      value = string.to_s.gsub(',', '.').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, parent_object)
+      end
+
+      hash
+    end
+
+  end
+
+end

data/lib/smooth_operator/validations.rb

@@ -1,15 +1,31 @@
 module SmoothOperator
-
   module Validations
 
     def valid?(context = nil)
-      Helpers.blank?(get_internal_data("errors"))
+      Helpers.blank?(_internal_errors)
     end
 
     def invalid?
       !valid?
     end
 
-  end
+    def _internal_errors
+      @_internal_errors ||= {}
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
 
+      def errors_key
+        Helpers.get_instance_variable(self, :errors_key, 'errors')
+      end
+
+      attr_writer :errors_key
+
+    end
+
+  end
 end

data/lib/smooth_operator/version.rb

@@ -1,3 +1,3 @@
 module SmoothOperator
-  VERSION = "1.20.10"
+  VERSION = "1.21.0"
 end

data/lib/smooth_operator.rb

@@ -9,16 +9,18 @@ require "smooth_operator/finder_methods"
 require "smooth_operator/relation/associations"
 
 module SmoothOperator
-  class Base < OpenStruct::Base
+  class Base < OpenStruct
 
+    extend Schema
     extend FinderMethods
+    extend Operator::HttpMethods
     extend Relation::Associations
     extend Translation if defined? I18n
 
-    include Schema
     include Operator
     include Persistence
     include FinderMethods
+    include Operator::HttpMethods
 
     self.strict_behaviour = true
 
@@ -36,11 +38,30 @@ module SmoothOperator
       include ActiveModel::Conversion
 
       def column_for_attribute(attribute_name)
-        type = get_attribute_type(attribute_name)
+        type = self.class.attribute_type(attribute_name)
 
         ActiveRecord::ConnectionAdapters::Column.new(attribute_name.to_sym, type, type)
       end
 
+      def save(relative_path = nil, data = {}, options = {})
+        # clear_server_errors
+        return false unless before_save
+
+        save_result = valid? ? super : false
+
+        # import_server_errors
+
+        after_save if valid? && save_result
+
+        save_result
+      end
+
+      def before_save
+        true
+      end
+
+      def after_save; end
+
     end
   end
 end

data/spec/smooth_operator/attribute_assignment_spec.rb

@@ -8,15 +8,6 @@ describe SmoothOperator::AttributeAssignment 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 }) }
 
@@ -84,16 +75,16 @@ describe SmoothOperator::AttributeAssignment do
         end
       end
 
-      context "when the .unknown_hash_class is set to SmoothOperator::OpenStruct::Base" do
+      context "when the .unknown_hash_class is set to SmoothOperator::OpenStruct" 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
+        it "a new instance of SmoothOperator::OpenStruct will be initialized with that hash" do
           address = subject.address
 
-          expect(address).to be_instance_of(SmoothOperator::OpenStruct::Base)
+          expect(address).to be_instance_of(SmoothOperator::OpenStruct)
           expect(address.street).to eq('something')
 
-          expect(address.postal_code).to be_instance_of(SmoothOperator::OpenStruct::Base)
+          expect(address.postal_code).to be_instance_of(SmoothOperator::OpenStruct)
           expect(address.postal_code.code).to eq('123')
         end
       end

data/spec/smooth_operator/finder_methods_spec.rb

@@ -8,11 +8,6 @@ shared_examples_for "finder method" do
   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
@@ -39,13 +34,13 @@ describe SmoothOperator::FinderMethods do
 
   describe ".find" do
     context "when the server returns a single hash" do
-      let(:user) { subject.find(5).object }
+      let(:user) { subject.find(5).data }
 
       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 }
+      let(:user) { subject.find("5/with_metadata").data }
 
       it_behaves_like "finder method"
 
@@ -61,7 +56,7 @@ describe SmoothOperator::FinderMethods do
     context "when the server returns an array" do
       it "it should return a RemoteCall instance an array that contains a subject's class instance, one for every array's entry" do
         remote_call = subject.find(:all)
-        users = remote_call.objects
+        users = remote_call.data
 
         expect(users).to be_instance_of(Array)
         expect(users[0]).to be_instance_of(subject)
@@ -70,7 +65,7 @@ describe SmoothOperator::FinderMethods do
 
       it "if any of the array entries is not a hash, it shall not be converted or alteread" do
         remote_call = subject.find('misc_array')
-        users = remote_call.objects
+        users = remote_call.data
 
         expect(users).to be_instance_of(Array)
         expect(users[0]).to be_instance_of(subject)

data/spec/smooth_operator/persistence_spec.rb

@@ -133,13 +133,6 @@ describe SmoothOperator::Persistence, helpers: :persistence do
     subject { new_user }
     let(:method_to_execute) { :reload }
 
-    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'
@@ -155,11 +148,6 @@ describe SmoothOperator::Persistence, helpers: :persistence do
       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
@@ -194,7 +182,7 @@ describe SmoothOperator::Persistence, helpers: :persistence do
   end
 
   describe ".create" do
-    
+
     subject { created_subject }
     let(:method_arguments) { [] }
 
@@ -263,7 +251,7 @@ describe SmoothOperator::Persistence, helpers: :persistence do
         expect(subject.destroyed?).to be(true)
       end
     end
-  
+
     context "after a failed execution of #destroy" do
       subject { existing_user }
       before  { subject.destroy('', { status: 422 }) }
@@ -387,7 +375,7 @@ describe SmoothOperator::Persistence, helpers: :persistence do
   end
 
   describe "#destroy" do
-    
+
     let(:method_to_execute) { :destroy }
     let(:method_arguments) { [] }
 

data/spec/smooth_operator/{model_name_spec.rb → resource_name_spec.rb}

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe SmoothOperator::ModelName do
+describe SmoothOperator::ResourceName do
 
   describe "#known_attributes" do
     let(:initial_attributes_keys) { attributes_for(:user).keys.map(&:to_s) }

data/spec/support/models/address.rb

@@ -1,7 +1,5 @@
 class Address < SmoothOperator::Base
 
-  self.dirty_attributes
-
   self.resource_name = ''
 
   self.endpoint_user = 'admin'

data/spec/support/models/user.rb

@@ -1,5 +1,5 @@
 module User
-  
+
   class Base < SmoothOperator::Base
 
     self.resource_name = 'user'
@@ -19,9 +19,9 @@ module User
   end
 
   module UnknownHashClass
-    
+
     class OpenStructBase < User::Base
-      self.unknown_hash_class = SmoothOperator::OpenStruct::Base
+      self.unknown_hash_class = SmoothOperator::OpenStruct
     end
 
     class None < User::Base

data/spec/support/models/user_with_address_and_posts.rb

@@ -1,7 +1,7 @@
 module UserWithAddressAndPosts
-  
+
   class Father < User::Base
-    
+
     self.resource_name = 'user'
 
     schema(
@@ -36,10 +36,10 @@ module UserWithAddressAndPosts
     self.update_http_verb = :patch
 
   end
-  
+
 
   module UserBlackListed
-    
+
     class Father < ::UserWithAddressAndPosts::Son
 
       attributes_black_list_add "last_name"
@@ -55,7 +55,7 @@ module UserWithAddressAndPosts
   end
 
   module UserWhiteListed
-    
+
     class Father < ::UserWithAddressAndPosts::Son
 
       attributes_white_list_add "id"
@@ -69,7 +69,7 @@ module UserWithAddressAndPosts
     end
 
   end
-  
+
   class UserWithMyMethod < UserWithAddressAndPosts::Son
 
     def my_method
@@ -78,12 +78,4 @@ module UserWithAddressAndPosts
 
   end
 
-  class DirtyAttributes < UserWithAddressAndPosts::Son
-
-    self.dirty_attributes
-
-    self.unknown_hash_class = SmoothOperator::OpenStruct::Dirty
-
-  end
-
 end