smooth_operator 1.3.0 → 1.8.0

data/lib/smooth_operator/remote_call.rb

@@ -0,0 +1,70 @@
+module SmoothOperator
+
+  module RemoteCall
+
+    class Base
+
+      extend Forwardable
+
+      attr_reader :response
+
+      attr_accessor :object
+
+      def_delegator :response, :status, :http_status
+
+      def_delegators :response, :success?, :headers, :body
+
+      def initialize(response, object_class = nil)
+        @response, @object_class = response, object_class
+      end
+
+
+      def failure?
+        http_status.between?(400, 499)
+      end
+
+      def error?
+        http_status.between?(500, 599)
+      end
+
+      def parsed_response
+        require 'json' unless defined? JSON
+        
+        begin
+          JSON.parse(body)
+        rescue JSON::ParserError
+          nil
+        end
+      end
+
+      def status
+        error? ? nil : success?
+      end
+
+      def objects
+        object.respond_to?(:length) ? object : []
+      end
+
+      def data
+        object.nil? ? parsed_response : object
+      end
+
+    end
+
+    class ConnectionFailed
+
+      attr_reader :data, :object, :objects, :status, :headers, :body
+
+      def http_status; 0; end
+
+      def error?; true; end
+
+      def success?; false; end
+
+      def failure?; false; end
+
+    end
+
+  end
+
+end

data/lib/smooth_operator/serialization.rb

@@ -3,121 +3,65 @@ module SmoothOperator
   module Serialization
 
     def to_hash(options = nil)
-      Helpers.symbolyze_keys(serializable_hash(options) || {})
+      Helpers.symbolyze_keys serializable_hash(options)
     end
-
-    def attributes; to_hash; end
-
+    
+    alias :attributes :to_hash
+    
     def to_json(options = nil)
       require 'json' unless defined? JSON
-
-      JSON(serializable_hash(options) || {})
+      
+      JSON(serializable_hash(options))
     end
 
     def read_attribute_for_serialization(attribute)
       send(attribute)
     end
 
-    def serializable_hash(options = nil)
-      hash = {}
+    def serializable_hash(options = nil) # Code inspired in ActiveSupport#serializable_hash
       options ||= {}
-      method_names = HelperMethods.method_names(self, options)
-      attribute_names = HelperMethods.attribute_names(self, options)
 
-      attribute_names.each do |attribute_name|
-        attribute_name, attribute_value = HelperMethods
-          .serialize_normal_or_rails_way(self, attribute_name, options)
+      attribute_names = internal_data.keys.sort
 
-        hash[attribute_name] = attribute_value
+      if only = options[:only]
+        attribute_names &= [*only].map(&:to_s)
+      elsif except = options[:except]
+        attribute_names -= [*except].map(&:to_s)
       end
 
-      method_names.each do |method_name|
-        hash[method_name.to_s] = HelperMethods.serialize_normal_attribute(send(method_name), method_name, options[method_name])
-      end
+      method_names = [*options[:methods]].select { |n| respond_to?(n) }
+
+      hash = {}
+      
+      attribute_names.each { |attribute_name| hash[attribute_name] = read_attribute_for_hashing(attribute_name, options) }
+      method_names.each { |method_name| hash[method_name.to_s] = send(method_name) }
 
       hash
     end
 
-    module HelperMethods
-
-      extend self
-
-      def attribute_names(object, options)
-        attribute_names = object.internal_data.keys.sort
-
-        if only = options[:only]
-          white_list = [*only].map(&:to_s)
-
-          attribute_names &= white_list
-        elsif except = options[:except]
-          black_list = [*except].map(&:to_s)
-
-          attribute_names -= black_list
-        end
-
-        attribute_names
-      end
-
-      def method_names(object, options)
-        [*options[:methods]].select { |n| object.respond_to?(n) }
-      end
-
-      def serialize_normal_or_rails_way(object, attribute_name, options)
-        _attribute_name, attribute_sym = attribute_name, attribute_name.to_sym
-
-        reflection = object.class.respond_to?(:reflect_on_association) &&
-          object.class.reflect_on_association(attribute_sym)
-
-        attribute_options = options[attribute_sym]
 
-        if reflection && reflection.rails_serialization?
-          attribute_value = serialize_has_many_attribute(object, reflection, attribute_name, attribute_options)
+    protected ##################### PROTECTED ###################
 
-          _attribute_name = "#{attribute_name}_attributes"
-        end
+    def read_attribute_for_hashing(attribute_name, options)
+      object = read_attribute_for_serialization(attribute_name)
 
-        attribute_value ||= serialize_normal_attribute(object, attribute_name, attribute_options)
+      _options = options[attribute_name] || options[attribute_name.to_sym]
 
-        [_attribute_name, attribute_value]
-      end
-
-      def serialize_has_many_attribute(parent_object, reflection, attribute_name, options)
-        return nil unless reflection.has_many?
-
-        object = parent_object.read_attribute_for_serialization(attribute_name)
-
-        object.reduce({}) do |hash, array_entry|
-          id = Helpers.present?(array_entry.id) ? array_entry.id : Helpers.generated_id
-
-          hash[id.to_s] = attribute_to_hash(array_entry, options)
-
-          hash
-        end
-      end
-
-      def serialize_normal_attribute(parent_object, attribute_name, options)
-        if parent_object.respond_to?(:read_attribute_for_serialization)
-          object = parent_object.read_attribute_for_serialization(attribute_name)
-        else
-          object = parent_object
-        end
-
-        if object.is_a?(Array)
-          object.map { |array_entry| attribute_to_hash(array_entry, options) }
-        else
-          attribute_to_hash(object, options)
-        end
+      if object.is_a?(Array)
+        object.map { |array_entry| attribute_to_hash(array_entry, _options) }
+      else
+        attribute_to_hash(object, _options)
       end
+    end
 
-      def attribute_to_hash(object, options = nil)
-        if object.respond_to?(:serializable_hash)
-          Helpers.symbolyze_keys(object.serializable_hash(options))
-        else
-          object
-        end
+    def attribute_to_hash(object, options = nil)
+      if object.respond_to?(:serializable_hash)
+        Helpers.symbolyze_keys(object.serializable_hash(options))
+      else
+        object
       end
-
     end
 
   end
+
 end

data/lib/smooth_operator/translation.rb

@@ -1,33 +1,20 @@
 module SmoothOperator
+
   module Translation
 
     def human_attribute_name(attribute_key_name, options = {})
-      HelperMethods.translate(
-        "attributes.#{model_name.i18n_key}.#{attribute_key_name}",
-        options
-      )
-    end
-
-    module HelperMethods
-
-      extend self
-
-      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
-
+      no_translation = "-- no translation --"
+      
+      defaults = ["smooth_operator.attributes.#{name.underscore}.#{attribute_key_name}".to_sym]
+      defaults << "activerecord.attributes.#{name.underscore}.#{attribute_key_name}".to_sym
+      defaults << options[:default] if options[:default]
+      defaults.flatten!
+      defaults << no_translation
+      options[:count] ||= 1
+      
+      I18n.translate(defaults.shift, options.merge(default: defaults))
     end
 
   end
-end
+
+end

data/lib/smooth_operator/type_converter.rb

@@ -0,0 +1,69 @@
+module SmoothOperator
+
+  module TypeConverter
+
+    extend self
+
+    def convert(value, type)
+      case type
+
+      when :string, :text, String
+        value.to_s
+      
+      when :int, :integer, Integer, Fixnum
+        TypeConverter.to_int(value)
+
+      when :date, Date
+        TypeConverter.to_date(value)
+
+      when :float, Float
+        TypeConverter.to_float(value)
+
+      when :bool, :boolean
+        TypeConverter.to_boolean(value)
+
+      when :datetime, :date_time, DateTime
+        TypeConverter.to_datetime(value)
+
+      else
+        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
+  
+  end
+  
+end

data/lib/smooth_operator/validations.rb

@@ -1,37 +1,15 @@
 module SmoothOperator
+
   module Validations
 
     def valid?(context = nil)
-      Helpers.blank?(induced_errors)
+      Helpers.blank?(get_internal_data("errors"))
     end
 
     def invalid?
       !valid?
     end
 
-    def induced_errors
-      @induced_errors ||= {}
-    end
-
-    def clear_induced_errors
-      @induced_errors = {}
-    end
-
-    def induce_errors(value)
-      @induced_errors = value
-    end
-
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-
-      def errors_key
-        get_option :errors_key, 'errors'
-      end
-
-    end
-
   end
+
 end

data/lib/smooth_operator/version.rb

@@ -1,3 +1,3 @@
 module SmoothOperator
-  VERSION = '1.3.0'
+  VERSION = "1.8.0"
 end

data/smooth_operator.gemspec

@@ -12,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, using faraday gem to stablish remote calls"}
+  spec.summary       = %q{Simple and fully customizable alternative to ActiveResource, using faraday gem to stablish parallel remote calls"}
   spec.homepage      = "https://github.com/goncalvesjoao/smooth_operator"
   spec.license       = "MIT"
 
@@ -20,13 +20,9 @@ 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_dependency "json", '~> 1.5'
-  spec.add_dependency "faraday", "~> 0.8"
-  spec.add_dependency "typhoeus", "~> 0.6"
-
-  # this is necessary if you want to typhoeus to correctly encode arrays
-  # spec.add_dependency "ethon", :git => 'https://github.com/goncalvesjoao/ethon'
+  
+  spec.add_dependency "json"
+  spec.add_dependency 'faraday', '> 0.9.0.rc5'
 end

data/spec/factories/user_factory.rb

@@ -1,6 +1,6 @@
 FactoryGirl.define do
   
-  factory :user, class: User::Base do
+  factory :user, class: User do
     
     id 1
     admin true
@@ -9,8 +9,7 @@ FactoryGirl.define do
 
     trait :with_address_and_posts do
       address { { street: 'my_street' } }
-      # posts [{ id: 1, body: 'post1' }, { id: 2, body: 'post2' }]
-      posts [{ id: 1 }, { id: 2 }]
+      posts [{ body: 'post1' }, { body: 'post2' }]
     end
     factory :user_with_address_and_posts, traits: [:with_address_and_posts]
 
@@ -21,12 +20,12 @@ FactoryGirl.define do
 
   end
 
-  factory :white_list, class: User::Base do
+  factory :white_list, class: User do
     id 1
     first_name 'John'
   end
   
-  factory :black_list, class: User::Base do
+  factory :black_list, class: User do
     admin true
     last_name 'Doe'
   end