smooth_operator 0.4.4 → 1.2.0

data/lib/smooth_operator/translation.rb

@@ -0,0 +1,27 @@
+module SmoothOperator
+
+  module Translation
+
+    def human_attribute_name(attribute_key_name, options = {})
+      _translate("attributes.#{model_name.i18n_key}.#{attribute_key_name}", options = {})
+    end
+
+
+    private ###################### PRIVATE #########################
+
+    def _translate(namespace = '', options = {})
+      no_translation = "-- no translation --"
+      
+      defaults = ["smooth_operator.#{namespace}".to_sym]
+      defaults << "activerecord.#{namespace}".to_sym
+      defaults << options[:default] if options[:default]
+      defaults.flatten!
+      defaults << no_translation
+      
+      options = { count: 1, default: defaults }.merge!(options.except(:default))
+      I18n.translate(defaults.shift, options)
+    end
+
+  end
+
+end

data/lib/smooth_operator/validations.rb

@@ -0,0 +1,15 @@
+module SmoothOperator
+
+  module Validations
+
+    def valid?(context = nil)
+      Helpers.blank?(get_internal_data("errors"))
+    end
+
+    def invalid?
+      !valid?
+    end
+
+  end
+
+end

data/lib/smooth_operator/version.rb

@@ -1,3 +1,3 @@
 module SmoothOperator
-  VERSION = "0.4.4"
+  VERSION = "1.2.0"
 end

data/lib/smooth_operator.rb

@@ -1,7 +1,28 @@
+require "smooth_operator/version"
+require "smooth_operator/helpers"
+require "smooth_operator/operator"
+require "smooth_operator/persistence"
+require "smooth_operator/translation"
+require "smooth_operator/open_struct"
+require "smooth_operator/finder_methods"
+require "smooth_operator/relation/associations"
+
 module SmoothOperator
-  # Thank you Mario! But our princess is in another castle!
-end
+  class Base < OpenStruct::Base
 
-require "smooth_operator/version"
-require "smooth_operator/core"
-require "smooth_operator/base"
+    extend FinderMethods
+    extend Translation if defined? I18n
+
+    include Operator
+    include Persistence
+    include FinderMethods
+    include Relation::Associations
+
+    self.strict_behaviour = true
+
+    def self.smooth_operator?
+      true
+    end
+
+  end
+end

data/smooth_operator.gemspec

@@ -1,6 +1,9 @@
 # coding: utf-8
+
 lib = File.expand_path('../lib', __FILE__)
+
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
 require 'smooth_operator/version'
 
 Gem::Specification.new do |spec|
@@ -9,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["João Gonçalves"]
   spec.email         = ["goncalves.joao@gmail.com"]
   spec.description   = %q{ActiveResource alternative}
-  spec.summary       = %q{Simple and fully customizable alternative to ActiveResource, based on httparty gem}
+  spec.summary       = %q{Simple and fully customizable alternative to ActiveResource, using faraday gem to stablish remote calls"}
   spec.homepage      = "https://github.com/goncalvesjoao/smooth_operator"
   spec.license       = "MIT"
 
@@ -17,7 +20,13 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
-
+  
   spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
+  
+  spec.add_dependency "json"
+  spec.add_dependency "faraday", "~> 0.8.9"
+  spec.add_dependency "typhoeus", "~> 0.6.8"
+
+  # this is necessary if you want to typhoeus to correctly encode arrays
+  # spec.add_dependency "ethon", :git => 'https://github.com/goncalvesjoao/ethon'
 end

data/spec/factories/user_factory.rb

@@ -0,0 +1,34 @@
+FactoryGirl.define do
+  
+  factory :user, class: User::Base do
+    
+    id 1
+    admin true
+    last_name 'Doe'
+    first_name 'John'
+
+    trait :with_address_and_posts do
+      address { { street: 'my_street' } }
+      # posts [{ id: 1, body: 'post1' }, { id: 2, body: 'post2' }]
+      posts [{ id: 1 }, { id: 2 }]
+    end
+    factory :user_with_address_and_posts, traits: [:with_address_and_posts]
+
+    trait :has_my_method do
+      my_method 'my_method'
+    end
+    factory :user_with_my_method, traits: [:with_address_and_posts, :has_my_method]
+
+  end
+
+  factory :white_list, class: User::Base do
+    id 1
+    first_name 'John'
+  end
+  
+  factory :black_list, class: User::Base do
+    admin true
+    last_name 'Doe'
+  end
+
+end

data/spec/require_helper.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require 'bundler/setup'
+require 'smooth_operator'
+
+Bundler.require :test, :default
+
+Dir.chdir("spec/") do
+  Dir["support/**/*.rb"].each { |file| require file }
+end

data/spec/smooth_operator/attribute_assignment_spec.rb

@@ -0,0 +1,351 @@
+require 'date'
+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)) }
+
+      context "when there are no changes to attributes's white and black list" do
+        it 'it should return all attributes' do
+          expect(subject.to_hash).to eq(attributes_for(:user_with_address_and_posts))
+        end
+      end
+
+      context "when there are changes to attributes's white list" do
+        subject(:user_white_listed) { UserWithAddressAndPosts::UserWhiteListed::Son.new(attributes_for(:user_with_address_and_posts)) }
+
+        it 'it should return only the white listed' do
+          expect(user_white_listed.to_hash).to eq(attributes_for(:white_list))
+        end
+      end
+
+      context "when there are changes to attributes's black list" do
+        subject(:user_black_listed) { UserWithAddressAndPosts::UserBlackListed::Son.new(attributes_for(:user_with_address_and_posts)) }
+
+        it 'it should not return the black listed' do
+          expect(user_black_listed.to_hash).not_to include(attributes_for(:black_list))
+        end
+      end
+    end
+
+    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::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 .unknown_hash_class is unused", current: true do
+        subject { User::Base.new(address: { street: 'something', postal_code: { code: '123' } }) }
+
+        it "a new instance of OpenStruct will be initialized with that hash" do
+          address = subject.address
+
+          expect(address).to be_instance_of(OpenStruct)
+          expect(address.street).to eq('something')
+
+          expect(address.postal_code).to be_instance_of(OpenStruct)
+          expect(address.postal_code.code).to eq('123')
+        end
+      end
+
+      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
+
+          expect(creator).to be_instance_of(Hash)
+          expect(creator[:first_name]).to eq('admin')
+
+          expect(creator[:address]).to be_instance_of(Hash)
+          expect(creator[:address][:street]).to eq('something')
+        end
+      end
+    end
+
+    context "when there is no declared schema" do
+      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
+        expect(subject.to_hash).to eq(attributes_for(:user))
+      end
+
+      it "it should populate 'known_attributes' with the keys of the received hash" do
+        expect(subject.known_attributes.to_a).to match_array(expected_internal_data.keys)
+      end
+    end
+
+    context "when there is a known schema and the received hash has an attribute" do
+      subject { UserWithAddressAndPosts::Son }
+
+      context "that is declared (in schema) as an nil" do
+
+        it "when the attributes's value is '1', should return '1'" do
+          expect(subject.new(complex_field: '1').complex_field).to eq('1')
+        end
+
+        it "when the attributes's value is ['1', '2'], should return ['1', '2']" do
+          expect(subject.new(complex_field: ['1', '2']).complex_field).to eq(['1', '2'])
+        end
+
+        it "when the attributes's value is 1, should be converted to 1" do
+          expect(subject.new(complex_field: 1).complex_field).to eq(1)
+        end
+
+        it "when the attributes's value is { first_name: ['1', '2'] }, should be converted to { first_name: ['1', '2'] }" do
+          expect(subject.new(complex_field: { first_name: ['1', '2'] }).complex_field).to eq({ first_name: ['1', '2'] })
+        end
+
+        it "when the attributes's value is -1, should be converted to -1" do
+          expect(subject.new(complex_field: -1).complex_field).to eq(-1)
+        end
+
+        it "when the attributes's value is 0.35, should be converted to 0.35" do
+          expect(subject.new(complex_field: 0.35).complex_field).to eq(0.35)
+        end
+
+      end
+
+      context "that is declared (in schema) as an integer" do
+
+        it "when the attributes's value is '1', should be converted to 1" do
+          expect(subject.new(age: '1').age).to be(1)
+        end
+
+        it "when the attributes's value is '-1', should be converted to -1" do
+          expect(subject.new(age: '-1').age).to be(-1)
+        end
+
+        it "when the attributes's value is 's-10s', should be converted to -10" do
+          expect(subject.new(age: 's-10s').age).to be(-10)
+        end
+
+        it "when the attributes's value is ' 10s', should be converted to 10" do
+          expect(subject.new(age: ' 10s').age).to be(10)
+        end
+
+        it "when the attributes's value is 123, should be converted to 123" do
+          expect(subject.new(age: 123).age).to be(123)
+        end
+
+        it "when the attributes's value is -5, should be converted to -5" do
+          expect(subject.new(age: -5).age).to be(-5)
+        end
+
+      end
+
+      context "that is declared (in schema) as an float" do
+
+        it "when the attributes's value is '1', should be converted to 1" do
+          expect(subject.new(price: '1').price).to eq(1.0)
+        end
+
+        it "when the attributes's value is '-1', should be converted to -1" do
+          expect(subject.new(price: '-1').price).to eq(-1.0)
+        end
+
+        it "when the attributes's value is 's-10s', should be converted to -10" do
+          expect(subject.new(price: 's-10s').price).to eq(-10.0)
+        end
+
+        it "when the attributes's value is ' 10s', should be converted to 10" do
+          expect(subject.new(price: ' 10s').price).to eq(10.0)
+        end
+
+        it "when the attributes's value is 123, should be converted to 123" do
+          expect(subject.new(price: 123).price).to eq(123.0)
+        end
+
+        it "when the attributes's value is -5, should be converted to -5" do
+          expect(subject.new(price: -5).price).to eq(-5.0)
+        end
+
+        it "when the attributes's value is '12.3', should be converted to 12.3" do
+          expect(subject.new(price: '12.3').price).to eq(12.3)
+        end
+
+        it "when the attributes's value is 's12.3s', should be converted to 12.3" do
+          expect(subject.new(price: 's12.3s').price).to eq(12.3)
+        end
+
+        it "when the attributes's value is 's12,3s', should be converted to 12.3" do
+          expect(subject.new(price: 's12,3s').price).to eq(12.3)
+        end
+
+        it "when the attributes's value is 1.2, should be converted to 1.2" do
+          expect(subject.new(price: 1.2).price).to eq(1.2)
+        end
+
+      end
+
+      context "that is declared (in schema) as an boolean" do
+
+        it "when the attributes's value is true, should be converted to true" do
+          expect(subject.new(manager: true).manager).to be(true)
+        end
+
+        it "when the attributes's value is false, should be converted to false" do
+          expect(subject.new(manager: false).manager).to be(false)
+        end
+
+        it "when the attributes's value is 'true', should be converted to true" do
+          expect(subject.new(manager: 'true').manager).to be(true)
+        end
+
+        it "when the attributes's value is 'false', should be converted to false" do
+          expect(subject.new(manager: 'false').manager).to be(false)
+        end
+
+        it "when the attributes's value is '1', should be converted to true" do
+          expect(subject.new(manager: '1').manager).to be(true)
+        end
+
+        it "when the attributes's value is '0', should be converted to false" do
+          expect(subject.new(manager: '0').manager).to be(false)
+        end
+
+        it "when the attributes's value is '', should be converted to nil" do
+          expect(subject.new(manager: '').manager).to be_nil
+        end
+
+        it "when the attributes's value is 'something', should be converted to nil" do
+          expect(subject.new(manager: 'something').manager).to be_nil
+        end
+
+      end
+
+      context "that is declared (in schema) as an existing class" do
+
+        it "if the attribute's value is an hash a new instance of that class will be initialized with that hash" do
+          address = subject.new(address: { street: 'something' }).address
+
+          expect(address).to be_instance_of(Address)
+          expect(address.street).to eq('something')
+        end
+
+        it "if the attribute's value is not an hash, then that value will be simply cloned" do
+          expect(subject.new(address: 'something').address).to eq('something')
+        end
+
+        it "if the attribute's value is an array, a new instance of that class will be initialized for each array entry" do
+          posts = subject.new(posts: [{ body: 'post1' }, { body: 'post2' }]).posts
+
+          expect(posts.length).to be(2)
+
+          expect(posts[0]).to be_instance_of(Post)
+          expect(posts[0].body).to eq('post1')
+
+          expect(posts[1]).to be_instance_of(Post)
+          expect(posts[1].body).to eq('post2')
+        end
+
+      end
+
+      context "that is declared (in schema) as a date" do
+
+        it "if the attribute's value is a valid date string" do
+          dob = subject.new(dob: '2-2-2222').dob
+
+          expect(dob).to be_instance_of(Date)
+          expect(dob.day).to be(2)
+          expect(dob.month).to be(2)
+          expect(dob.year).to be(2222)
+        end
+
+        it "if the attribute's value is a valid date" do
+          date_now = DateTime.now
+          dob = subject.new(dob: date_now).dob
+
+          expect(dob).to be_instance_of(DateTime)
+          expect(dob).to eq(date_now)
+        end
+
+        it "if the attribute's value is an invalid date string, the returning value should be nil" do
+          expect(subject.new(dob: '2s-2-2222').dob).to be_nil
+        end
+
+      end
+
+      context "that is declared (in schema) as a datetime" do
+
+        it "if the attribute's value is a valid datetime string" do
+          date = subject.new(date: '2-2-2222 12:30').date
+
+          expect(date).to be_instance_of(DateTime)
+          expect(date.day).to be(2)
+          expect(date.month).to be(2)
+          expect(date.year).to be(2222)
+          expect(date.hour).to be(12)
+          expect(date.min).to be(30)
+        end
+
+        it "if the attribute's value is a valid datetime" do
+          date_now = DateTime.now
+          date = subject.new(date: date_now).date
+
+          expect(date).to be_instance_of(DateTime)
+          expect(date).to eq(date_now)
+        end
+
+        it "if the attribute's value is an invalid datetime string, the returning value should be nil" do
+          expect(subject.new(date: '2s-2-2222').date).to be_nil
+        end
+
+      end
+
+    end
+
+  end
+
+end

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