smooth_operator 1.21.1 → 1.21.3

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    N2I1ZjBjNDAwNjFjNzE5ODJkNmE4ZTA0MGViZjYxMjgzOGNiNzM2ZQ==
+    MGI1ZGJkM2IzYmEyNDhmNjg0OGU2MDExNjExYWFmZmFiMDQ3NTVmMg==
   data.tar.gz: !binary |-
-    YzBmMWExNmJiMzJjNWMxMTFhNDFlYWQ4YjBmMGI4ZmNlNTUyZjJlOQ==
+    ZjUzODkzZjVjNDc4YTZjZjI4ODY0YmUyNmMwYjhhMjUwYTQ0NDNlMA==
 SHA512:
   metadata.gz: !binary |-
-    YTYxZmRjNmVlNGViM2MyZjU0NjJiNDhkNWMyN2QyNmU0MmU1YmEzOWY4ZWRh
-    NDE2MDliOTAwZjNjMzRkZDliYmQ3MDc4NjAyMDZjMGRjMGFhZjQ4OWU2ZGYw
-    YjVlYzkwNjYxZjJiNTgzNDM5M2E4MzFkNzQ0Y2U3MGM2YTRhYTA=
+    ZDU3MGZjZWU0YzI0MzVlYTVhMWRlM2VjMDhjYzRlN2ZjOTYzMjQ1ZGNjMTgz
+    M2Q2NTg3Mzc4MTRiMWVhNWM5ZDcxOGM0MmM1ZTQ4OWQxYmEyNzMwZGE5NmQy
+    ZjIxOGVmMDA0M2E5NmM2YmQxYjgzNTliZmUwYmFlOTE2NDBmZDE=
   data.tar.gz: !binary |-
-    N2I4MjM1YjI1MzE5YjhjOGJjNDZkMzU0MTBhMzE5OGFhMTA3MDIwOWNlYzE2
-    OWI2N2I0MjdiYTg1NDhlZDNkMmRiNDI5YmEyOWNjNzY2YWVhZGZlMzcyMDUw
-    ZWMzZmNjYjZkNDAzOTdmOWJjNTAxMTU3MjA2MzQ2M2VkOGRkNWE=
+    MTk5NTg5N2QzNGExZWEwYzZkOTg4MDA0ODJmMDU5ZmVkYzExYTFlMDVlNmU2
+    ODA5ZWQxNTExMzE1OWQ0NmM1ODhiMzUxMmRiZWZkYzBiNzJhODk5YmIzMzVi
+    MTkwMTdjNDhhMWJjZDk4YzI5MzMxZmJiOGM0OTliNWRhNTBkOGQ=

data/lib/smooth_operator/associations/association_reflection.rb

@@ -60,6 +60,10 @@ module SmoothOperator
         has_many?
       end
 
+      def rails_serialization?
+        options[:rails_serialization] == true
+      end
+
       private ################################# private
 
       def foreign_key_default

data/lib/smooth_operator/associations.rb

@@ -4,16 +4,16 @@ 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)
+    def has_many(association, options = {})
+      accepts_nested_objects(association, :has_many, options)
     end
 
-    def has_one(nested_object_name, options = {})
-      accepts_nested_objects(nested_object_name, :has_one, options)
+    def has_one(association, options = {})
+      accepts_nested_objects(association, :has_one, options)
     end
 
-    def belongs_to(nested_object_name, options = {})
-      accepts_nested_objects(nested_object_name, :belongs_to, options)
+    def belongs_to(association, options = {})
+      accepts_nested_objects(association, :belongs_to, options)
     end
 
     def reflections
@@ -28,8 +28,16 @@ module SmoothOperator
       macro ? reflections.values.select { |reflection| reflection.macro == macro } : reflections.values
     end
 
+    def rails_serialization
+      Helpers.get_instance_variable(self, :rails_serialization, false)
+    end
+
+    attr_writer :rails_serialization
+
     protected ###################### PROTECTED ###################
 
+    # TODO: THIS MUST GO TO A HELPER_METHODS MODULE
+
     def accepts_nested_objects(association, macro, options = {})
       options = parse_options(options, { macro: macro })
 
@@ -93,6 +101,10 @@ module SmoothOperator
     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
 

data/lib/smooth_operator/attribute_assignment.rb

@@ -13,29 +13,42 @@ module SmoothOperator
 
     attr_reader :_options, :_meta_data
 
-    def assign_attributes(_attributes = {}, options = {})
-      return nil unless _attributes.is_a?(Hash)
+    def assign_attributes(attributes = {}, options = {})
+      return nil unless attributes.is_a?(Hash)
 
-      attributes = _attributes = Helpers.stringify_keys(_attributes)
-
-      if _attributes.include?(self.class.resource_name)
-        attributes = _attributes.delete(self.class.resource_name)
-        @_meta_data = _attributes
-      end
+      attributes = _extract_attributes(attributes)
 
       induce_errors(attributes.delete(self.class.errors_key))
 
-      options.each { |key, value| @_options[key] = value } if options.is_a? Hash
+      @_options.merge!(options) if options.is_a? Hash
 
       attributes.each do |name, value|
         next unless allowed_attribute(name)
 
-        internal_data_push(name, value)
+        if respond_to?("#{name}=")
+          send("#{name}=", value)
+        else
+          internal_data_push(name, value)
+        end
       end
     end
 
     protected ################# PROTECTED METHODS DOWN BELOW ###################
 
+    def _extract_attributes(attributes)
+      _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
+
+      attributes
+    end
+
     def before_initialize(attributes, options); end
 
     def after_initialize(attributes, options); end

data/lib/smooth_operator/helpers.rb

@@ -4,6 +4,10 @@ module SmoothOperator
 
     extend self
 
+    def generated_id
+      Time.now.to_f.to_s.split('.')[1]
+    end
+
     def primary_key(object)
       object.internal_data_get(object.class.primary_key)
     end

data/lib/smooth_operator/serialization.rb

@@ -6,7 +6,6 @@ module SmoothOperator
       Helpers.symbolyze_keys(serializable_hash(options) || {})
     end
 
-    # alias :attributes :to_hash
     def attributes; to_hash; end
 
     def to_json(options = nil)
@@ -22,58 +21,98 @@ module SmoothOperator
     def serializable_hash(options = nil)
       hash = {}
       options ||= {}
+      method_names = HelperMethods.method_names(self, options)
+      attribute_names = HelperMethods.attribute_names(self, options)
 
-      _attribute_names(options).each do |attribute_name|
-        hash[attribute_name] = _read_attribute_for_hashing(attribute_name, options)
+      attribute_names.each do |attribute_name|
+        attribute_name, attribute_value = HelperMethods
+          .serialize_normal_or_rails_way(self, attribute_name, options)
+
+        hash[attribute_name] = attribute_value
       end
 
-      method_names(options).each do |method_name|
+      method_names.each do |method_name|
         hash[method_name.to_s] = send(method_name)
       end
 
       hash
     end
 
+    module HelperMethods
+
+      extend self
+
+      def attribute_names(object, options)
+        attribute_names = object.internal_data.keys.sort
 
-    protected ##################### PROTECTED ###################
+        if only = options[:only]
+          white_list = [*only].map(&:to_s)
 
-    # TODO: COMPLEX METHOD
-    def _attribute_names(options)
-      attribute_names = internal_data.keys.sort
+          attribute_names &= white_list
+        elsif except = options[:except]
+          black_list = [*except].map(&:to_s)
 
-      if only = options[:only]
-        attribute_names &= [*only].map(&:to_s)
-      elsif except = options[:except]
-        attribute_names -= [*except].map(&:to_s)
+          attribute_names -= black_list
+        end
+
+        attribute_names
       end
 
-      attribute_names
-    end
+      def method_names(object, options)
+        [*options[:methods]].select { |n| object.respond_to?(n) }
+      end
 
-    def method_names(options)
-      [*options[:methods]].select { |n| 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.reflect_on_association(attribute_sym)
+
+        attribute_options = options[attribute_sym]
 
-    def _read_attribute_for_hashing(attribute_name, options)
-      object = read_attribute_for_serialization(attribute_name)
+        if reflection && reflection.rails_serialization?
+          attribute_value = serialize_has_many_attribute(object, reflection, attribute_name, attribute_options)
 
-      _options = options[attribute_name] || options[attribute_name.to_sym]
+          _attribute_name = "#{attribute_name}_attributes"
+        end
 
-      if object.is_a?(Array)
-        object.map { |array_entry| _attribute_to_hash(array_entry, _options) }
-      else
-        _attribute_to_hash(object, _options)
+        attribute_value ||= serialize_normal_attribute(object, attribute_name, attribute_options)
+
+        [_attribute_name, attribute_value]
       end
-    end
 
-    def _attribute_to_hash(object, options = nil)
-      if object.respond_to?(:serializable_hash)
-        Helpers.symbolyze_keys(object.serializable_hash(options))
-      else
-        object
+      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)
+        object = parent_object.read_attribute_for_serialization(attribute_name)
+
+        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
+      end
+
     end
 
   end
-
 end

data/lib/smooth_operator/version.rb

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

data/spec/support/models/post.rb

@@ -6,8 +6,10 @@ class Post < SmoothOperator::Base
 
   self.endpoint = 'http://localhost:4567/'
 
-  has_many :comments
+  self.rails_serialization = true
 
-  belongs_to :address
+  has_many :comments#, rails_serialization: true
+
+  belongs_to :address#, rails_serialization: true
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smooth_operator
 version: !ruby/object:Gem::Version
-  version: 1.21.1
+  version: 1.21.3
 platform: ruby
 authors:
 - João Gonçalves
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-01 00:00:00.000000000 Z
+date: 2014-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler