smooth_operator 1.21.0 → 1.21.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    M2EyMTBiMWExYzQ4Mjc0ZDM3M2IyMGRkZmFjMTEzYmVjYzg5NDJkMw==
+    N2I1ZjBjNDAwNjFjNzE5ODJkNmE4ZTA0MGViZjYxMjgzOGNiNzM2ZQ==
   data.tar.gz: !binary |-
-    YmZjYzA1YWM0ZjJmYzMwOWZjN2ZmMzVkMjRiNDFlYzc5MjVmYzNlNQ==
+    YzBmMWExNmJiMzJjNWMxMTFhNDFlYWQ4YjBmMGI4ZmNlNTUyZjJlOQ==
 SHA512:
   metadata.gz: !binary |-
-    Mzg4ZGRhNDA4NWJjNmEzNDkzMWNjYjZhZTM5YTFiMGRiMmUzZWNmOWFmMzg4
-    NjFiMGVjMDJhZGRkNTExNzdhNTAzOTU4MjQxNmVmZTBiMzIxM2Q5Y2I5MzZh
-    MTlhYTZiYWYxNWU1OTZjZmM0YjQ0ZjFlMTYxMjIxZjE5NWMzMmE=
+    YTYxZmRjNmVlNGViM2MyZjU0NjJiNDhkNWMyN2QyNmU0MmU1YmEzOWY4ZWRh
+    NDE2MDliOTAwZjNjMzRkZDliYmQ3MDc4NjAyMDZjMGRjMGFhZjQ4OWU2ZGYw
+    YjVlYzkwNjYxZjJiNTgzNDM5M2E4MzFkNzQ0Y2U3MGM2YTRhYTA=
   data.tar.gz: !binary |-
-    ODljN2NlMTBlZDM1NWYwMzhlZmJjMDBkNDM3ZGEwOTYzZmNmZGFmNDQwMjUy
-    OWFhNjNmODRlNmUxYmI3MzdlZWQzZGEzZjg1MzE3ZmZkZDY2NmI5YjZiMDNj
-    OTdhNTA0OWNlMTk5NmM2OTNkZTlkZTlkODZhNDZiODhhNmVhZjc=
+    N2I4MjM1YjI1MzE5YjhjOGJjNDZkMzU0MTBhMzE5OGFhMTA3MDIwOWNlYzE2
+    OWI2N2I0MjdiYTg1NDhlZDNkMmRiNDI5YmEyOWNjNzY2YWVhZGZlMzcyMDUw
+    ZWMzZmNjYjZkNDAzOTdmOWJjNTAxMTU3MjA2MzQ2M2VkOGRkNWE=

data/README.md

@@ -1,11 +1,19 @@
-# SmoothOperator
+# SmoothOperator [![Code Climate](https://codeclimate.com/repos/536a7b9f6956801228014b02/badges/13f79897976274a9de33/gpa.png)](https://codeclimate.com/repos/536a7b9f6956801228014b02/feed)
 
 Ruby gem, that mimics the ActiveRecord behaviour but through external API's.
 It's a lightweight and flexible alternative to ActiveResource, that responds to a REST API like you expect it too.
 
-Depends only on Faraday gem, no need for ActiveSupport or any other Active* gem.
+Be sure to check out this micro-services example: https://github.com/goncalvesjoao/micro-services-example
 
-Although if I18n is present it will respond to .human_attribute_name method and if ActiveModel is present it will make use of 'ActiveModel::Name' to improve .model_name method.
+Where a Rails4 app lists/creates/edits and destroys blog posts from a Padrino (aka Sinatra) app, using SmoothOperator::Rails instead of ActiveRecord::Base classes.
+
+This micro-services example will also feature other cool stuff like:
+- parallel requests;
+- using HTTP PATCH verb for saving instead of PUT;
+- form errors with simple_form gem;
+- nested objects using cocoon gem;
+- endless-pagination with kaminari gem
+- and others...
 
 ---
 

data/lib/smooth_operator/array_with_meta_data.rb

@@ -13,7 +13,7 @@ module SmoothOperator
       attributes.delete(resources_name)
 
       @meta_data = attributes
-      
+
       define_metada_methods
 
       super(@internal_array)

data/lib/smooth_operator/{relation → associations}/association_reflection.rb

@@ -1,7 +1,7 @@
-require "smooth_operator/relation/reflection"
+require "smooth_operator/associations/reflection"
 
 module SmoothOperator
-  module Relation
+  module Associations
     class AssociationReflection < Reflection
 
       attr_reader :related_reflection, :macro

data/lib/smooth_operator/{relation/array_relation.rb → associations/has_many_relation.rb}

@@ -1,6 +1,6 @@
 module SmoothOperator
-  module Relation
-    class ArrayRelation < SimpleDelegator
+  module Associations
+    class HasManyRelation < SimpleDelegator
 
       attr_reader :object, :association
 

data/lib/smooth_operator/{relation → associations}/reflection.rb

@@ -1,5 +1,5 @@
 module SmoothOperator
-  module Relation
+  module Associations
     class Reflection
 
       attr_reader :name, :klass, :options

data/lib/smooth_operator/associations.rb

@@ -0,0 +1,100 @@
+require "smooth_operator/associations/has_many_relation"
+require "smooth_operator/associations/association_reflection"
+
+module SmoothOperator
+  module Associations
+
+    def has_many(nested_object_name, options = {})
+      accepts_nested_objects(nested_object_name, :has_many, options)
+    end
+
+    def has_one(nested_object_name, options = {})
+      accepts_nested_objects(nested_object_name, :has_one, options)
+    end
+
+    def belongs_to(nested_object_name, options = {})
+      accepts_nested_objects(nested_object_name, :belongs_to, options)
+    end
+
+    def reflections
+      Helpers.get_instance_variable(self, :reflections, {})
+    end
+
+    def reflect_on_association(association)
+      reflections[association]
+    end
+
+    def reflect_on_all_associations(macro = nil)
+      macro ? reflections.values.select { |reflection| reflection.macro == macro } : reflections.values
+    end
+
+    protected ###################### PROTECTED ###################
+
+    def accepts_nested_objects(association, macro, options = {})
+      options = parse_options(options, { macro: macro })
+
+      reflection = AssociationReflection.new(association, Reflection.new(name, {}), options)
+
+      schema(association => reflection.klass)
+
+      reflections.merge!(association => reflection)
+
+      if reflection.has_many?
+        define_has_many_association_method(reflection, association)
+      else
+        define_single_association_method(reflection, association)
+      end
+
+      self.send(:attr_reader, "#{association}_attributes".to_sym)
+
+      define_attributes_setter_methods(reflection, association)
+    end
+
+    private ####################### PRIVATE ######################
+
+    def define_has_many_association_method(reflection, association)
+      define_method(association) do
+        has_many_relation = instance_variable_get("@#{association}")
+
+        if has_many_relation.nil?
+          has_many_relation = HasManyRelation.new(self, association)
+
+          instance_variable_set("@#{association}", has_many_relation)
+        end
+
+        has_many_relation.send(:refresh)
+
+        has_many_relation
+      end
+    end
+
+    def define_single_association_method(reflection, association)
+      define_method(association) { internal_data_get(association.to_s) }
+
+      define_method("build_#{association}") do |attributes = {}|
+        new_instance = reflection.klass.new(attributes)
+
+        internal_data_push(association, new_instance)
+
+        new_instance
+      end
+    end
+
+    def define_attributes_setter_methods(reflection, association)
+      define_method("#{association}_attributes=") do |attributes|
+        instance_variable_set("@#{association}_attributes", attributes)
+
+        attributes = attributes.values if reflection.has_many?
+
+        internal_data_push(association.to_s, attributes)
+      end
+    end
+
+    def parse_options(options, default_options)
+      options = options.is_a?(Hash) ? options.merge(default_options) : default_options
+
+      Helpers.symbolyze_keys(options)
+    end
+
+  end
+end

data/lib/smooth_operator/attribute_assignment.rb

@@ -23,7 +23,7 @@ module SmoothOperator
         @_meta_data = _attributes
       end
 
-      @_internal_errors = attributes.delete(self.class.errors_key)
+      induce_errors(attributes.delete(self.class.errors_key))
 
       options.each { |key, value| @_options[key] = value } if options.is_a? Hash
 
@@ -34,10 +34,6 @@ module SmoothOperator
       end
     end
 
-    def _parent_object
-      _options[:parent_object]
-    end
-
     protected ################# PROTECTED METHODS DOWN BELOW ###################
 
     def before_initialize(attributes, options); end

data/lib/smooth_operator/http_methods.rb

@@ -0,0 +1,17 @@
+module SmoothOperator
+  module HttpMethods
+
+    HTTP_VERBS = %w[get post put patch delete]
+
+    HTTP_VERBS.each do |method|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{method}(relative_path = '', params = {}, options = {})
+          make_the_call(:#{method}, relative_path, params, options) do |remote_call|
+            block_given? ? yield(remote_call) : remote_call
+          end
+        end
+      RUBY
+    end
+
+  end
+end

data/lib/smooth_operator/operator.rb

@@ -12,10 +12,12 @@ module SmoothOperator
 
       relative_path = resource_path(relative_path)
 
-      if !_parent_object.nil? && options[:ignore_parent] != true
-        id = Helpers.primary_key(_parent_object)
+      parent_object = _options[:parent_object]
 
-        options[:resources_name] ||= "#{_parent_object.class.resources_name}/#{id}/#{self.class.resources_name}"
+      if !parent_object.nil? && options[:ignore_parent] != true
+        id = Helpers.primary_key(parent_object)
+
+        options[:resources_name] ||= "#{parent_object.class.resources_name}/#{id}/#{self.class.resources_name}"
       end
 
       self.class.make_the_call(http_verb, relative_path, data, options) do |remote_call|
@@ -23,8 +25,6 @@ module SmoothOperator
       end
     end
 
-    protected ######################## PROTECTED ###################
-
     def resource_path(relative_path)
       if Helpers.absolute_path?(relative_path)
         Helpers.remove_initial_slash(relative_path)
@@ -41,24 +41,6 @@ module SmoothOperator
       base.extend(ClassMethods)
     end
 
-    ########################### MODULES BELLOW ###############################
-
-    module HttpMethods
-
-      HTTP_VERBS = %w[get post put patch delete]
-
-      HTTP_VERBS.each do |method|
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{method}(relative_path = '', params = {}, options = {})
-            make_the_call(:#{method}, relative_path, params, options) do |remote_call|
-              block_given? ? yield(remote_call) : remote_call
-            end
-          end
-        RUBY
-      end
-
-    end
-
     module ClassMethods
 
       OPTIONS = [:endpoint, :endpoint_user, :endpoint_pass, :timeout]
@@ -76,15 +58,15 @@ module SmoothOperator
       attr_writer :headers
 
       def make_the_call(http_verb, relative_path = '', data = {}, options = {})
-        operator_args = operator_method_args(http_verb, relative_path, data, options)
+        options = HelperMethods.populate_options(self, options)
 
-        if Helpers.present?(operator_args[4][:hydra])
-          operator_call = Operators::Typhoeus
-        else
-          operator_call = Operators::Faraday
-        end
+        resource_path = resource_path(relative_path, options)
+
+        params, data = *HelperMethods.strip_params(self, http_verb, data)
 
-        operator_call.make_the_call(*operator_args) do |remote_call|
+        operator = HelperMethods.get_me_an_operator(options)
+
+        operator.make_the_call(http_verb, resource_path, params, data, options) do |remote_call|
           block_given? ? yield(remote_call) : remote_call
         end
       end
@@ -93,45 +75,52 @@ module SmoothOperator
         params
       end
 
-      protected #################### PROTECTED ##################
-
-      def operator_method_args(http_verb, relative_path, data, options)
-        options = populate_options(options)
+      def resource_path(relative_path, options)
+        resources_name = options[:resources_name] || self.resources_name
 
-        [http_verb, resource_path(relative_path, options), *strip_params(http_verb, data), options]
+        if Helpers.present?(resources_name)
+          Helpers.present?(relative_path) ? "#{resources_name}/#{relative_path}" : resources_name
+        else
+          relative_path.to_s
+        end
       end
 
-      private #################### PRIVATE ##################
-
-      def populate_options(options)
-        options ||= {}
+    end
 
-        OPTIONS.each { |option| options[option] ||= send(option) }
+    module HelperMethods
 
-        options[:headers] = headers.merge(options[:headers] || {})
+      extend self
 
-        options
+      def get_me_an_operator(options)
+        if options[:parallel_connection].nil?
+          Operators::Faraday
+        else
+          Operators::Typhoeus
+        end
       end
 
-      def resource_path(relative_path, options)
-        _resources_name = options[:resources_name] || self.resources_name
+      def populate_options(object, options)
+        options ||= {}
 
-        if Helpers.present?(_resources_name)
-          Helpers.present?(relative_path) ? "#{_resources_name}/#{relative_path}" : _resources_name
-        else
-          relative_path.to_s
+        ClassMethods::OPTIONS.each do |option|
+          options[option] ||= object.send(option)
         end
+
+        options[:headers] = object.headers.merge(options[:headers] || {})
+
+        options
       end
 
-      def strip_params(http_verb, data)
+      def strip_params(object, http_verb, data)
         data ||= {}
 
         if [:get, :head, :delete].include?(http_verb)
-          [query_string(data), nil]
+          [object.query_string(data), nil]
         else
-          [query_string({}), data]
+          [object.query_string({}), data]
         end
       end
+
     end
 
   end

data/lib/smooth_operator/persistence.rb

@@ -43,7 +43,7 @@ module SmoothOperator
         raise 'UnknownPath'
       end
 
-      _persistence_call(:reload, relative_path, data, options) do |remote_call|
+      make_a_persistence_call(:reload, relative_path, data, options) do |remote_call|
         block_given? ? yield(remote_call) : remote_call.status
       end
     end
@@ -67,7 +67,7 @@ module SmoothOperator
     def destroy(relative_path = nil, data = {}, options = {})
       return false unless persisted?
 
-      _persistence_call(:destroy, relative_path, data, options) do |remote_call|
+      make_a_persistence_call(:destroy, relative_path, data, options) do |remote_call|
         @destroyed = true if remote_call.status
 
         block_given? ? yield(remote_call) : remote_call.status
@@ -77,7 +77,7 @@ module SmoothOperator
     protected ######################### PROTECTED ##################
 
     def create(relative_path, data, options)
-      _persistence_call(:create, relative_path, data, options) do |remote_call|
+      make_a_persistence_call(:create, relative_path, data, options) do |remote_call|
         @new_record = false if remote_call.status
 
         block_given? ? yield(remote_call) : remote_call
@@ -85,7 +85,7 @@ module SmoothOperator
     end
 
     def update(relative_path, data, options)
-      _persistence_call(:update, relative_path, data, options) do |remote_call|
+      make_a_persistence_call(:update, relative_path, data, options) do |remote_call|
         block_given? ? yield(remote_call) : remote_call
       end
     end
@@ -102,7 +102,7 @@ module SmoothOperator
 
     private ##################### PRIVATE ##################
 
-    def _persistence_call(method, relative_path, data, options)
+    def make_a_persistence_call(method, relative_path, data, options)
       options ||= {}
 
       http_verb = options[:http_verb] || self.class.methods_vs_http_verbs[method]

data/lib/smooth_operator/schema.rb

@@ -6,8 +6,7 @@ module SmoothOperator
     end
 
     def internal_structure
-      Helpers.get_instance_variable(self, :internal_structure,
-        { primary_key => nil })
+      Helpers.get_instance_variable(self, :internal_structure, {})
     end
 
     def known_attribute?(attribute)

data/lib/smooth_operator/validations.rb

@@ -2,15 +2,23 @@ module SmoothOperator
   module Validations
 
     def valid?(context = nil)
-      Helpers.blank?(_internal_errors)
+      Helpers.blank?(induced_errors)
     end
 
     def invalid?
       !valid?
     end
 
-    def _internal_errors
-      @_internal_errors ||= {}
+    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)

data/lib/smooth_operator/version.rb

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

data/lib/smooth_operator.rb

@@ -5,22 +5,23 @@ require "smooth_operator/operator"
 require "smooth_operator/persistence"
 require "smooth_operator/translation"
 require "smooth_operator/open_struct"
+require "smooth_operator/http_methods"
+require "smooth_operator/associations"
 require "smooth_operator/finder_methods"
-require "smooth_operator/relation/associations"
 
 module SmoothOperator
   class Base < OpenStruct
 
     extend Schema
+    extend HttpMethods
+    extend Associations
     extend FinderMethods
-    extend Operator::HttpMethods
-    extend Relation::Associations
     extend Translation if defined? I18n
 
     include Operator
+    include HttpMethods
     include Persistence
     include FinderMethods
-    include Operator::HttpMethods
 
     self.strict_behaviour = true
 
@@ -37,6 +38,8 @@ module SmoothOperator
       include ActiveModel::Validations::Callbacks
       include ActiveModel::Conversion
 
+      validate :validate_induced_errors, :validate_nested_objects
+
       def column_for_attribute(attribute_name)
         type = self.class.attribute_type(attribute_name)
 
@@ -44,12 +47,11 @@ module SmoothOperator
       end
 
       def save(relative_path = nil, data = {}, options = {})
-        # clear_server_errors
         return false unless before_save
 
-        save_result = valid? ? super : false
+        clear_induced_errors
 
-        # import_server_errors
+        save_result = valid? ? super : false
 
         after_save if valid? && save_result
 
@@ -62,6 +64,22 @@ module SmoothOperator
 
       def after_save; end
 
+      protected ################# PROTECTED ###################
+
+      def validate_induced_errors
+        induced_errors.each do |key, value|
+          [*value].each do |_value|
+            self.errors.add(key, _value) unless self.errors.added?(key, _value)
+          end
+        end
+
+        Helpers.blank?(induced_errors)
+      end
+
+      def validate_nested_objects
+        # nested_objects.map { |reflection, nested_object| nested_object.valid? }.all?
+      end
+
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smooth_operator
 version: !ruby/object:Gem::Version
-  version: 1.21.0
+  version: 1.21.1
 platform: ruby
 authors:
 - João Gonçalves
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-31 00:00:00.000000000 Z
+date: 2014-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -82,20 +82,21 @@ files:
 - console.rb
 - lib/smooth_operator.rb
 - lib/smooth_operator/array_with_meta_data.rb
+- lib/smooth_operator/associations.rb
+- lib/smooth_operator/associations/association_reflection.rb
+- lib/smooth_operator/associations/has_many_relation.rb
+- lib/smooth_operator/associations/reflection.rb
 - lib/smooth_operator/attribute_assignment.rb
 - lib/smooth_operator/delegation.rb
 - lib/smooth_operator/finder_methods.rb
 - lib/smooth_operator/helpers.rb
+- lib/smooth_operator/http_methods.rb
 - lib/smooth_operator/internal_data.rb
 - lib/smooth_operator/open_struct.rb
 - lib/smooth_operator/operator.rb
 - lib/smooth_operator/operators/faraday.rb
 - lib/smooth_operator/operators/typhoeus.rb
 - lib/smooth_operator/persistence.rb
-- lib/smooth_operator/relation/array_relation.rb
-- lib/smooth_operator/relation/association_reflection.rb
-- lib/smooth_operator/relation/associations.rb
-- lib/smooth_operator/relation/reflection.rb
 - lib/smooth_operator/remote_call/base.rb
 - lib/smooth_operator/remote_call/errors/connection_failed.rb
 - lib/smooth_operator/remote_call/errors/timeout.rb

data/lib/smooth_operator/relation/associations.rb

@@ -1,102 +0,0 @@
-require "smooth_operator/relation/array_relation"
-require "smooth_operator/relation/association_reflection"
-
-module SmoothOperator
-  module Relation
-    module Associations
-
-      def has_many(nested_object_name, options = {})
-        accepts_nested_objects(nested_object_name, :has_many, options)
-      end
-
-      def has_one(nested_object_name, options = {})
-        accepts_nested_objects(nested_object_name, :has_one, options)
-      end
-
-      def belongs_to(nested_object_name, options = {})
-        accepts_nested_objects(nested_object_name, :belongs_to, options)
-      end
-
-      def reflections
-        Helpers.get_instance_variable(self, :reflections, {})
-      end
-
-      def reflect_on_association(association)
-        reflections[association]
-      end
-
-      def reflect_on_all_associations(macro = nil)
-        macro ? reflections.values.select { |reflection| reflection.macro == macro } : reflections.values
-      end
-
-      protected ###################### PROTECTED ###################
-
-      def accepts_nested_objects(association, macro, options = {})
-        options = parse_options(options, { macro: macro })
-
-        reflection = AssociationReflection.new(association, Reflection.new(name, {}), options)
-
-        schema(association => reflection.klass)
-
-        reflections.merge!(association => reflection)
-
-        if reflection.has_many?
-          define_has_many_association_method(reflection, association)
-        else
-          define_single_association_method(reflection, association)
-        end
-
-        self.send(:attr_reader, "#{association}_attributes".to_sym)
-
-        define_attributes_setter_methods(reflection, association)
-      end
-
-      private ####################### PRIVATE ######################
-
-      def define_has_many_association_method(reflection, association)
-        define_method(association) do
-          array_relation = instance_variable_get("@#{association}")
-
-          if array_relation.nil?
-            array_relation = ArrayRelation.new(self, association)
-
-            instance_variable_set("@#{association}", array_relation)
-          end
-
-          array_relation.send(:refresh)
-
-          array_relation
-        end
-      end
-
-      def define_single_association_method(reflection, association)
-        define_method(association) { internal_data_get(association.to_s) }
-
-        define_method("build_#{association}") do |attributes = {}|
-          new_instance = reflection.klass.new(attributes)
-
-          internal_data_push(association, new_instance)
-
-          new_instance
-        end
-      end
-
-      def define_attributes_setter_methods(reflection, association)
-        define_method("#{association}_attributes=") do |attributes|
-          instance_variable_set("@#{association}_attributes", attributes)
-
-          attributes = attributes.values if reflection.has_many?
-
-          internal_data_push(association.to_s, attributes)
-        end
-      end
-
-      def parse_options(options, default_options)
-        options = options.is_a?(Hash) ? options.merge(default_options) : default_options
-
-        Helpers.symbolyze_keys(options)
-      end
-
-    end
-  end
-end