smooth_operator 1.2.9 → 1.3.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NzlkNzFkMjI1Y2UyZTRlNzYwNWIxYWJmMTIwYjMxM2RmNzYxZWQ2Yg==
+    MmY1MDZiMTA3ZGQ4OThhNWZlNDA1YzgzNmRhZTg3YzE2OWQ0ZjM1ZQ==
   data.tar.gz: !binary |-
-    Njc2YzU4YTRjOTFiY2QxMmE1YjA3NDRkMWYxNzZmYWM5YzBlMzAxYQ==
+    M2VlYzc3M2ZlZmZiM2I4ZTI3ZmE4NTUyYzIzMzEwNTMwNTAwZTY5OQ==
 SHA512:
   metadata.gz: !binary |-
-    NmE0OGIxNDc4YTgxNDFmNjBhZDE3YzNjMzdhYmYzOWRmMzA4ZTU4NjgyZjQ1
-    YmI3YmZhYzE3YzVkODliYzhkNzc5YjU1MzViMzBjZGIwN2IzZThmMjI4ZmZl
-    ODNhYzI1MjY0NTY1ZTZhMTU2NjNlOTE1ZWU4MWRkYzY2ZWFmMTM=
+    ZmQ5NDFiMDAxYzhhNjQ0NjQzMjdlMTQ4MTM0OTg5MTRmOGZmOTlkM2YwZWJh
+    YzJhZDBmYjRlMzdjOGJiYmFmNTBkZjBmODk0Mzc4MmRmNTcxZDdhZTUwMTE5
+    MDQ4ZjU3YTM5YTYwMDI0Yjc4ODI2MjZmYTIwMGU4OGUwMGE5NGY=
   data.tar.gz: !binary |-
-    ZDQxZDg3ZjhiMGJjNWE3ZjJhOTQyMjE2NzM1OGI5YWMwOTQ0M2QzN2VhMGFi
-    YjcxMGZiZDg4ZDcyMTU3NzcyMTYyZTRkYTU2MThjNmRlYThlN2EzYzRmZjI4
-    ZDAyM2M2ZjU1MjVmYWFhZWI4NWU0YmVhMDBhMTU5ZGU1MzZkMTI=
+    NTEzZjYwMzQyN2IxMWRmMDc4ZjFlZGZmY2M4ZjY1Zjk4OTM5NTY3OGRkZTEw
+    OGJhMjNiYjVjOWRmMzQwZDJiZjM4ZGUwMjQ1YTVkZjZiNDhmMTkwMjEyZjhm
+    YmIxMmRmMzExMjQ2ZmFjNTNhMThjZjBiZmIwMmRjOGJkNWI0NGM=

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...
 
 ---
 
@@ -29,11 +37,14 @@ Or install it yourself as:
 
 ```ruby
 class MyBlogResource < SmoothOperator::Base
-  self.endpoint = 'http://myblog.com/api/v0'
 
   # HTTP BASIC AUTH
-  self.endpoint_user = 'admin'
-  self.endpoint_pass = 'admin'
+  options endpoint_user: 'admin',
+          endpoint_pass: 'admin',
+          endpoint: 'http://myblog.com/api/v0'
+
+  # OR
+  # smooth_operator_options
 end
 
 class Post < MyBlogResource
@@ -109,10 +120,16 @@ post = Post.new(id: 2, body: 'editing my second page')
 post.new_record? # false
 post.persisted?  # true
 
-post.save("#{post.id}/save_and_add_to_list", { admin: true, post: { author: 'Agent Smith', list_id: 1 } }, { timeout: 1 })
+post.save("save_and_add_to_list", { admin: true, post: { author: 'Agent Smith', list_id: 1 } }, { timeout: 1 })
 # Will make a PUT to 'http://myblog.com/api/v0/posts/2/save_and_add_to_list'
 # with { admin: true, post: { body: 'editing my second page', list_id: 1 } }
 # and will only wait 1sec for the server to respond.
+
+post.save('/#{post.id}/save_and_add_to_list')
+# Will make a PUT to 'http://myblog.com/api/v0/posts/2/save_and_add_to_list'
+
+post.save('/save_and_add_to_list')
+# Will make a PUT to 'http://myblog.com/api/v0/posts/save_and_add_to_list'
 ```
 
 ---
@@ -120,7 +137,9 @@ post.save("#{post.id}/save_and_add_to_list", { admin: true, post: { author: 'Age
 ### 2.4) Saving using HTTP Patch verb
 ```ruby
 class Page < MyBlogResource
-  self.update_http_verb = :patch
+  options update_http_verb: 'patch'
+  # OR
+  #smooth_operator_options update_http_verb: 'patch'
 end
 
 page = Page.find(2)
@@ -139,9 +158,9 @@ page.save # will make a http PATCH call to 'http://myblog.com/api/v0/pages/2'
 remote_call = Page.find(:all) # Will make a GET call to 'http://myblog.com/api/v0/pages'
                               # and will return a SmoothOperator::RemoteCall instance
 
-pages = remote_call.objects # 'pages = remote_call.data' also works
+pages = remote_call.data
 
-# If the server response is positive (http code between 200 and 299):
+# If the server response is positive (http code between 200 and 299, or 304):
   remote_call.ok? # true
   remote_call.not_processed? # false
   remote_call.error? # false
@@ -179,7 +198,9 @@ pages = remote_call.objects # 'pages = remote_call.data' also works
 remote_call = Page.find(2) # Will make a GET call to 'http://myblog.com/api/v0/pages/2'
                            # and will return a SmoothOperator::RemoteCall instance
 
-page = remote_call.object # 'page = remote_call.data' also works
+service_down = remote_call.error?
+
+page = remote_call.data
 ```
 
 ---
@@ -190,24 +211,59 @@ remote_call = Page.find('my_pages', { q: body_contains: 'link' }, { endpoint_use
 # will make a GET call to 'http://myblog.com/api/v0/pages/my_pages?q={body_contains="link"}'
 # and will change the HTTP BASIC AUTH credentials to user: 'admin' and pass: 'new_password' for this connection only.
 
+@service_down = remote_call.error?
+
 # If the server json response is an Array [{ id: 1 }, { id: 2 }]
-  pages = remote.data # will return an array with 2 Page's instances
-  pages[0].id # 1
-  pages[1].id # 2
+  @pages = remote.data # will return an array with 2 Page's instances
+  @pages[0].id # 1
+  @pages[1].id # 2
 
 # If the server json response is a Hash { id: 3 }
-  page = remote.data # will return a single Page instance
-  page.id # 3
+  @page = remote.data # will return a single Page instance
+  @page.id # 3
+
+# If the server json response is Hash with a key called 'pages' { current_page: 1, total_pages: 3, limit_value: 10, pages: [{ id: 4 }, { id: 5 }] }
+  @pages = remote.data # will return a single ArrayWithMetaData instance, that will allow you to access to both the Page's instances array and the metadata.
 
-# If the server json response is Hash with a key called 'pages' { page: 1, total: 3, pages: [{ id: 4 }, { id: 5 }] }
-  pages = remote.data # will return a single ArrayWithMetaData instance, that will allow you to access to both the Page's instances array and the metadata.
-  pages.page # 1
-  pages.total # 3
+  # @pages is now a valid object to work with kaminari
+  @pages.total_pages # 3
+  @pages.current_page # 1
+  @pages.limit_value # 10
 
-  pages[0].id # 4
-  pages[1].id # 5
+  @pages[0].id # 4
+  @pages[1].id # 5
 ```
 
+### 2.8) Keeping your session alive - custom HTTP Headers
+
+Controllers
+  ApplicationController
+  ```ruby
+  ```
+
+Models
+  SmoothResource
+  ```ruby
+  class SmoothResource < SmoothOperator::Rails
+
+    options headers: :custom_headers
+
+    def self.custom_headers
+      {
+        cookie: current_user.blog_cookie,
+        "X_CSRF_TOKEN" => current_user.blog_auth_token
+      }
+    end
+
+    protected ############## PROTECTED #################
+
+    def self.current_user
+      User.current_user
+    end
+
+  end
+  ```
+
 ---
 
 ## 3) Methods

data/console.rb

@@ -31,4 +31,6 @@ post = Post.new(comments: [{ id: 1, name: '1' }, { id: 2, name: '2' }], address:
 
 comments_attributes = { "0" => { id: 1, name: '3' }, "1" => { name: '4' } }
 
+comments_with_errors = { "0" => { id: 1, name: '3', errors: { body: ["can't be blank"] } }, "1" => { name: '4', errors: { body: ["can't be blank"] } } }
+
 binding.pry

data/lib/smooth_operator/array_with_meta_data.rb

@@ -1,22 +1,34 @@
 module SmoothOperator
-  class ArrayWithMetaData < ::SimpleDelegator
+  class ArrayWithMetaData < SimpleDelegator
 
     attr_reader :meta_data, :internal_array
 
     def initialize(attributes, object_class)
-      _attributes, _resources_name = attributes.dup, object_class.resources_name
+      resources_name = object_class.resources_name
 
-      @internal_array = [*_attributes[_resources_name]].map { |array_entry| object_class.new(array_entry).tap { |object| object.reloaded = true } }
-      _attributes.delete(_resources_name)
+      @internal_array = [*attributes[resources_name]].map do |array_entry|
+        object_class.new(array_entry)
+      end
 
-      @meta_data = _attributes
+      attributes.delete(resources_name)
+
+      @meta_data = attributes
+
+      define_metada_methods
 
       super(@internal_array)
     end
 
-    def method_missing(method, *args, &block)
-      _method = method.to_s
-      meta_data.include?(_method) ? meta_data[_method] : super
+    protected ############# PROTECTED ###################
+
+    def define_metada_methods
+      @meta_data.keys.each do |method|
+        instance_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{method}
+            @meta_data['#{method}']
+          end
+        RUBY
+      end
     end
 
   end

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

@@ -1,15 +1,15 @@
-require "smooth_operator/relation/reflection"
+require "smooth_operator/associations/reflection"
 
 module SmoothOperator
-  module Relation
+  module Associations
     class AssociationReflection < Reflection
 
       attr_reader :related_reflection, :macro
 
       def initialize(association, related_reflection, options)
         super(association, options)
-        @macro = options[:macro] || macro_default(association)
-        @related_reflection = related_reflection
+
+        @related_reflection, @macro = related_reflection, options[:macro]
       end
 
       def primary_key
@@ -60,12 +60,12 @@ module SmoothOperator
         has_many?
       end
 
-      private ################################# private
-
-      def macro_default(association)
-        Helpers.plural?(association) ? :has_many : :belongs_to
+      def rails_serialization?
+        options[:rails_serialization] == true
       end
 
+      private ################################# private
+
       def foreign_key_default
         if has_many? || has_one?
           "#{related_reflection.single_name}_id"

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
 
@@ -30,18 +30,8 @@ module SmoothOperator
 
       protected ############### PROTECTED ###############
 
-      # def method_missing(method, *args, &block)
-      #   if get_array.respond_to?(method)
-      #     puts "if true #{method} - #{args}"
-      #     get_array.send(method, *args)
-      #   else
-      #     puts "if else #{method}"
-      #     super
-      #   end
-      # end
-
       def get_array
-        data = object.get_internal_data(association.to_s)
+        data = object.internal_data_get(association.to_s)
 
         data.nil? ? [] : [*data]
       end

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
@@ -14,7 +14,7 @@ module SmoothOperator
         if options.include?(:class_name) && options[:class_name].nil?
           @klass = nil
         elsif @klass.is_a?(String)
-          @klass = @klass.constantize
+          @klass = @klass.constantize rescue OpenStruct
         end
       end
 

data/lib/smooth_operator/associations.rb

@@ -0,0 +1,110 @@
+require "smooth_operator/associations/has_many_relation"
+require "smooth_operator/associations/association_reflection"
+
+module SmoothOperator
+  module Associations
+
+    def has_many(association, options = {})
+      accepts_nested_objects(association, :has_many, options)
+    end
+
+    def has_one(association, options = {})
+      accepts_nested_objects(association, :has_one, options)
+    end
+
+    def belongs_to(association, options = {})
+      accepts_nested_objects(association, :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
+
+    def rails_serialization
+      get_option :rails_serialization, false
+    end
+
+    protected ###################### PROTECTED ###################
+
+    # TODO: THIS MUST GO TO A HELPER_METHODS MODULE
+
+    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
+
+      if options[:rails_serialization].nil?
+        options[:rails_serialization] = rails_serialization
+      end
+
+      Helpers.symbolyze_keys(options)
+    end
+
+  end
+end

data/lib/smooth_operator/attribute_assignment.rb

@@ -1,87 +1,51 @@
-require 'smooth_operator/attributes/base'
-require 'smooth_operator/attributes/dirty'
-require 'smooth_operator/attributes/normal'
-
 module SmoothOperator
   module AttributeAssignment
 
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    module ClassMethods
-
-      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)
-      end
-
-      def attributes_black_list
-        Helpers.get_instance_variable(self, :attributes_black_list, Set.new)
-      end
-
-      def attributes_white_list_add(*getters)
-        attributes_white_list.merge getters.map(&:to_s)
-      end
-
-      def attributes_black_list_add(*getters)
-        attributes_black_list.merge getters.map(&:to_s)
-      end
-
-      def dirty_attributes
-        @dirty_attributes = true
-      end
-
-      def dirty_attributes?
-        @dirty_attributes
-      end
-
-    end
-
     def initialize(attributes = {}, options = {})
       @_options = {}
 
       before_initialize(attributes, options)
 
-      assign_attributes attributes, options
+      assign_attributes(attributes, options)
 
       after_initialize(attributes, options)
     end
 
     attr_reader :_options, :_meta_data
 
+    def assign_attributes(attributes = {}, options = {})
+      attributes = _extract_attributes(attributes)
 
-    def assign_attributes(_attributes = {}, options = {})
-      return nil unless _attributes.is_a?(Hash)
+      return nil unless attributes.is_a?(Hash)
 
-      attributes = _attributes = Helpers.stringify_keys(_attributes)
+      induce_errors(attributes.delete(self.class.errors_key))
 
-      if _attributes.include?(self.class.resource_name)
-        attributes = _attributes.delete(self.class.resource_name)
-        @_meta_data = _attributes
-      end
+      @_options.merge!(options) if options.is_a? Hash
 
-      options.each { |key, value| @_options[key] = value } if options.is_a?(Hash)
+      attributes.each do |name, value|
+        next unless allowed_attribute(name)
 
-      attributes.each { |name, value| push_to_internal_data(name, value) }
+        send("#{name}=", value)
+      end
     end
 
-    def parent_object
-      _options[:parent_object]
-    end
+    protected ################# PROTECTED METHODS DOWN BELOW ###################
 
-    def has_data_from_server
-      _options[:from_server] == true
-    end
+    def _extract_attributes(attributes)
+      return nil unless attributes.is_a?(Hash)
 
-    alias :from_server :has_data_from_server
+      _attributes = Helpers.stringify_keys(attributes)
+
+      if _attributes.include?(self.class.resource_name)
+        attributes = _attributes.delete(self.class.resource_name)
+        @_meta_data = _attributes
+      else
+        attributes = _attributes
+        @_meta_data = {}
+      end
 
-    protected #################### PROTECTED METHODS DOWN BELOW ######################
+      attributes
+    end
 
     def before_initialize(attributes, options); end
 
@@ -97,5 +61,33 @@ module SmoothOperator
       end
     end
 
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      def unknown_hash_class
+        get_option :unknown_hash_class, ::OpenStruct
+      end
+
+      def attributes_white_list
+        Helpers.get_instance_variable(self, :attributes_white_list, Set.new)
+      end
+
+      def attributes_black_list
+        Helpers.get_instance_variable(self, :attributes_black_list, Set.new)
+      end
+
+      def attributes_white_list_add(*getters)
+        attributes_white_list.merge getters.map(&:to_s)
+      end
+
+      def attributes_black_list_add(*getters)
+        attributes_black_list.merge getters.map(&:to_s)
+      end
+
+    end
+
   end
 end

data/lib/smooth_operator/cookie_jar.rb

@@ -0,0 +1,21 @@
+module SmoothOperator
+  class CookieJar < Hash
+
+    def to_s
+      self.map { |key, value| "#{key}=#{value}"}.join("; ")
+    end
+
+    def parse(*cookie_strings)
+      cookie_strings.each do |cookie_string|
+        next unless cookie_string.is_a?(String)
+
+        key, value = cookie_string.split('; ').first.split('=', 2)
+
+        self[key] = value
+      end
+
+      self
+    end
+
+  end
+end

data/lib/smooth_operator/delegation.rb

@@ -1,5 +1,4 @@
 module SmoothOperator
-
   module Delegation
 
     def respond_to?(method, include_private = false)
@@ -7,48 +6,28 @@ module SmoothOperator
     end
 
     def method_missing(method, *args, &block)
-      method_type, method_name = *parse_method(method)
-
-      result = case method_type
-      when :was
-        get_internal_data(method_name, :was)
-      when :changed
-        get_internal_data(method_name, :changed?)
-      when :setter
-        return push_to_internal_data(method_name, args.first)
+      method_name = method.to_s
+
+      if !! ((method.to_s) =~ /=$/) #setter method
+        internal_data_push(method_name[0..-2], args.first)
+      elsif !self.class.strict_behaviour || known_attribute?(method_name)
+        internal_data_get(method_name)
       else
-        if !self.class.strict_behaviour || known_attribute?(method_name)
-          return get_internal_data(method_name)
-        end
+        super
       end
-
-      result.nil? ? super : result
     end
 
-
-    protected #################### PROTECTED ################
-
-    def parse_method(method)
-      method = method.to_s
-
-      if method?(method, /=$/)
-        [:setter, method[0..-2]]
-      elsif method?(method, /_was$/)
-        [:was, method[0..-5]]
-      elsif method?(method, /_changed\?$/)
-        [:changed, method[0..-10]]
-      else
-        [nil, method]
-      end
+    def self.included(base)
+      base.extend(ClassMethods)
     end
 
+    module ClassMethods
 
-    private #################### PRIVATE ################
+      def strict_behaviour
+        get_option :strict_behaviour, false
+      end
 
-    def method?(method, regex)
-      !! ((method.to_s) =~ regex)
     end
 
   end
-
 end