smooth_operator 1.2.1 → 1.2.5

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MTBiYTliODQ1NDM1MGU5NjlkMTVhNGJiMTExNjY3YjU4YjgzODQ2OA==
+    Yzk0YmZmM2Q1NDE4YWY5YWYxOTYyZjZkYTk2NjBjNjQ4MjMxNDU4ZQ==
   data.tar.gz: !binary |-
-    MDZkYjJmYTdlM2M3NmZmZmFlODVhMWZkNTBlNWQ1ZjNmZDg2YmY4YQ==
+    OTllZjJjMDgyOGYxY2VkZmM4NWUzN2Y3Y2E5NTgxZjdlMDU5NjE1Ng==
 SHA512:
   metadata.gz: !binary |-
-    YmRkOTExMDUzY2QwNDQ0ZTYwNDk2Y2FhYTE0YzA0YzkyYzg1ZDYwNjhjMTBm
-    YzBiNzg5NDNlY2YxZTZjZThjNTljYmEwNTQwMjAwNGY5ZGI0YjE2MWFjNmVl
-    ODNiYWNhNDVjMzIyZjIzMTkxNGE1MDYyYmQ0YWEwNWZjNDA3YjE=
+    YTgzYjIwYWEyMjE2YmJmZjk2YzllOWQyNWUwOWJjZTBlYjdjZDMxOTIwOWRh
+    NmQ0MTc5NWQ4NDY1ZjMzMWM4MzljODk4OTEwOWM0MjQyN2JjODA2NjYwMGEz
+    OTMzYjZlOTc2ZWY4YzU2ODNjOWE2MWYxMmIyYzJhNjE1ZTU3YTM=
   data.tar.gz: !binary |-
-    MTFmMmNjOGYwZTNjN2ZhNzczMWE3OGRhMTYyYjFkOTVjM2ZlNTRlYTgyNDE4
-    NzJkYjZjMGI5MzU1NTliOWJlMGQ0M2QzYzg4MDI5NjhjMDIwNDVlNmZlOTBl
-    OWVkZjM2MzM1ODc4OTg1MmE3NWIzMmE1N2NhMTIxMTU5NmI5N2E=
+    YmU2NDdkOTY3ZjEwOGFkMzNiMDJiNzAzM2NlYjM4MDc1NTc4MDI0N2JjMDEx
+    YzNkYTRlNWU2MDU4NzJmMjU2N2Q3NDExODkyNTU2YjJkZWFlNmFjOGM0N2Vl
+    ZmUxMTU4YTI2YzFiYTU1YTNlNTNkYjNlYTg0N2U5NThmZDQzZTg=

data/console.rb

@@ -29,16 +29,6 @@ LocalhostServer.new(TestServer.new, 4567)
 
 post = Post.new(comments: [{ id: 1, name: '1' }, { id: 2, name: '2' }], address: { id: 1, name: 'address' })
 
-class Test < SimpleDelegator
-  def reload
-    "TODO"
-  end
-end
-
-class Test2 < Test
-  def reload2
-    "TODO2"
-  end
-end
+comments_attributes = { "0" => { id: 1, name: '3' }, "1" => { name: '4' } }
 
 binding.pry

data/lib/smooth_operator/array_with_meta_data.rb

@@ -1,14 +1,8 @@
 module SmoothOperator
-  class ArrayWithMetaData < OpenStruct::Base
-
-    extend Forwardable
-
-    include Enumerable
+  class ArrayWithMetaData < ::SimpleDelegator
 
     attr_reader :meta_data, :internal_array
 
-    def_delegators :internal_array, :length, :<<, :[]
-
     def initialize(attributes, object_class)
       _attributes, _resources_name = attributes.dup, object_class.resources_name
 
@@ -16,10 +10,8 @@ module SmoothOperator
       _attributes.delete(_resources_name)
 
       @meta_data = _attributes
-    end
 
-    def each
-      internal_array.each { |array_entry| yield array_entry }
+      super(@internal_array)
     end
 
     def method_missing(method, *args, &block)

data/lib/smooth_operator/attribute_assignment.rb

@@ -3,7 +3,6 @@ require 'smooth_operator/attributes/dirty'
 require 'smooth_operator/attributes/normal'
 
 module SmoothOperator
-
   module AttributeAssignment
 
     def self.included(base)
@@ -69,7 +68,7 @@ module SmoothOperator
 
       options.each { |key, value| @_options[key] = value } if options.is_a?(Hash)
 
-      attributes.each { |name, value| push_to_internal_data(name, value, true) }
+      attributes.each { |name, value| push_to_internal_data(name, value) }
     end
 
     def parent_object

data/lib/smooth_operator/attribute_methods.rb

@@ -21,36 +21,45 @@ module SmoothOperator
       self.class.internal_structure[attribute.to_s]
     end
 
-    def push_to_internal_data(attribute_name, attribute_value, cast = false)
+    def push_to_internal_data(attribute_name, attribute_value)
       attribute_name = attribute_name.to_s
 
       return nil unless allowed_attribute(attribute_name)
 
       known_attributes.add attribute_name
 
-      if internal_data[attribute_name].nil?
-        initiate_internal_data(attribute_name, attribute_value, cast)
-      else
-        update_internal_data(attribute_name, attribute_value, cast)
-      end
+      attribute_name, attribute_value = extract_nested_attributes(attribute_name, attribute_value)
+
+      initiate_or_update_internal_data(attribute_name, attribute_value)
+
+      new_record_or_mark_for_destruction?(attribute_name, attribute_value)
+    end
+
+    protected #################### PROTECTED METHODS DOWN BELOW ######################
 
-      if self.class.respond_to?(:smooth_operator?)
-        trigger_necessary_events(attribute_name, attribute_value)
+    def extract_nested_attributes(attribute_name, attribute_value)
+      if !!(attribute_name =~ /_attributes$/)
+        attribute_name = attribute_name[0..-12]
+
+        if self.class.reflect_on_association(attribute_name.to_sym).has_many?
+          attribute_value = attribute_value.values
+        end
       end
+
+      [attribute_name, attribute_value]
     end
 
-    def column_for_attribute(attribute_name)
-      if defined?(ActiveRecord)
-        type = get_attribute_type(attribute_name)
-        ActiveRecord::ConnectionAdapters::Column.new(attribute_name.to_sym, type, type)
+    def initiate_or_update_internal_data(attribute_name, attribute_value)
+      if internal_data[attribute_name].nil?
+        initiate_internal_data(attribute_name, attribute_value)
       else
-        nil
+        update_internal_data(attribute_name, attribute_value)
       end
     end
 
-    protected #################### PROTECTED METHODS DOWN BELOW ######################
+    def new_record_or_mark_for_destruction?(attribute_name, attribute_value)
+      return nil unless self.class.respond_to?(:smooth_operator?)
 
-    def trigger_necessary_events(attribute_name, attribute_value)
       mark_for_destruction?(attribute_value) if attribute_name == self.class.destroy_key
 
       new_record?(true) if attribute_name == self.class.primary_key
@@ -58,21 +67,17 @@ module SmoothOperator
 
     private ######################## PRIVATE #############################
 
-    def initiate_internal_data(attribute_name, attribute_value, cast)
-      if cast
-        internal_data[attribute_name] = new_attribute_object(attribute_name, attribute_value)
+    def initiate_internal_data(attribute_name, attribute_value)
+      internal_data[attribute_name] = new_attribute_object(attribute_name, attribute_value)
 
-        internal_data[attribute_name] = internal_data[attribute_name].value unless self.class.dirty_attributes?
-      else
-        internal_data[attribute_name] = attribute_value
-      end
+      internal_data[attribute_name] = internal_data[attribute_name].value unless self.class.dirty_attributes?
     end
 
-    def update_internal_data(attribute_name, attribute_value, cast)
+    def update_internal_data(attribute_name, attribute_value)
       if self.class.dirty_attributes?
         internal_data[attribute_name].set_value(attribute_value, self)
       else
-        internal_data[attribute_name] = cast ? new_attribute_object(attribute_name, attribute_value).value : attribute_value
+        internal_data[attribute_name] = new_attribute_object(attribute_name, attribute_value).value
       end
     end
 

data/lib/smooth_operator/delegation.rb

@@ -2,7 +2,7 @@ module SmoothOperator
 
   module Delegation
 
-    def respond_to?(method)
+    def respond_to?(method, include_private = false)
       if known_attribute?(method)
         true
       else

data/lib/smooth_operator/operator.rb

@@ -5,18 +5,17 @@ require "smooth_operator/remote_call/errors/timeout"
 require "smooth_operator/remote_call/errors/connection_failed"
 
 module SmoothOperator
-
   module Operator
 
     def make_the_call(http_verb, relative_path = '', data = {}, options = {})
       options ||= {}
-      
+
       relative_path = resource_path(relative_path)
-      
+
       if !parent_object.nil? && options[:ignore_parent] != true
         options[:resources_name] ||= "#{parent_object.class.resources_name}/#{parent_object.get_primary_key}/#{self.class.resources_name}"
       end
-      
+
       self.class.make_the_call(http_verb, relative_path, data, options) do |remote_call|
         yield(remote_call)
       end
@@ -34,13 +33,12 @@ module SmoothOperator
       end
     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 = {})
@@ -78,7 +76,7 @@ module SmoothOperator
         else
           operator_call = Operators::Faraday
         end
-        
+
         operator_call.make_the_call(*operator_args) do |remote_call|
           block_given? ? yield(remote_call) : remote_call
         end
@@ -88,7 +86,6 @@ module SmoothOperator
         params
       end
 
-
       protected #################### PROTECTED ##################
 
       def operator_method_args(http_verb, relative_path, data, options)
@@ -97,7 +94,6 @@ module SmoothOperator
         [http_verb, resource_path(relative_path, options), *strip_params(http_verb, data), options]
       end
 
-
       private #################### PRIVATE ##################
 
       def populate_options(options)
@@ -106,7 +102,7 @@ module SmoothOperator
         OPTIONS.each { |option| options[option] ||= send(option) }
 
         options[:headers] = headers.merge(options[:headers] || {})
-        
+
         options
       end
 
@@ -122,17 +118,15 @@ module SmoothOperator
 
       def strip_params(http_verb, data)
         data ||= {}
-        
+
         if [:get, :head, :delete].include?(http_verb)
           [query_string(data), nil]
         else
           [query_string({}), data]
         end
       end
-
     end
 
-    
     include HttpMethods
 
     def self.included(base)

data/lib/smooth_operator/relation/array_relation.rb

@@ -4,8 +4,12 @@ module SmoothOperator
   module Relation
     class ArrayRelation < SingleRelation
 
-      def reload2
-        "TODO2"
+      def data
+        super || []
+      end
+
+      def reload
+        "TODO"
       end
 
     end

data/lib/smooth_operator/relation/associations.rb

@@ -10,13 +10,29 @@ module SmoothOperator
       end
 
       def get_relation(relation_name)
-        relations[relation_name] ||= self.class.build_relation(relation_name, get_internal_data(relation_name))
+        if relations.include?(relation_name)
+          relations[relation_name]
+        else
+          relations[relation_name] = build_relation(relation_name)
+        end
       end
 
       def self.included(base)
         base.extend(ClassMethods)
       end
 
+      protected ################### PROTECTED ###################
+
+      def build_relation(relation_name)
+        if self.class.reflect_on_association(relation_name.to_sym).has_many?
+          ArrayRelation.new(self, relation_name)
+        elsif Helpers.present? get_internal_data(relation_name)
+          SingleRelation.new(self, relation_name)
+        else
+          nil
+        end
+      end
+
       module ClassMethods
 
         def has_many(nested_object_name, options = {})
@@ -43,32 +59,26 @@ module SmoothOperator
           macro ? reflections.values.select { |reflection| reflection.macro == macro } : reflections.values
         end
 
-        def build_relation(relation_name, data)
-          if reflections[relation_name.to_sym].has_many?
-            ArrayRelation.new(data || [], relation_name)
-          else
-            SingleRelation.new(data, relation_name)
-          end
-        end
-
         protected ###################### PROTECTED ###################
 
         def accepts_nested_objects(nested_object_name, macro, options = {})
-          default_options = { macro: macro }
-          options = options.is_a?(Hash) ? options.merge(default_options) : default_options
-          options = Helpers.symbolyze_keys(options)
+          options = parse_options(options, { macro: macro })
 
           reflection = AssociationReflection.new(nested_object_name, Reflection.new(name, {}), options)
 
-          self.send(:attr_accessor, "#{nested_object_name}_attributes".to_sym)
-          self.instance_variable_set("@reflections", reflections.merge(nested_object_name => reflection))
-
-          define_method("existing_#{nested_object_name}") { existing_nested_objects(nested_object_name) }
-          define_method("build_#{reflection.single_name}") { |attributes = {}, nested_object = nil| build_nested_object(nested_object_name, attributes, nested_object) }
+          reflections.merge!(nested_object_name => reflection)
 
           schema(nested_object_name => reflection.klass)
         end
 
+        private ####################### PRIVATE ######################
+
+        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

data/lib/smooth_operator/relation/single_relation.rb

@@ -1,16 +1,19 @@
 module SmoothOperator
   module Relation
-    class SingleRelation < ::SimpleDelegator
+    class SingleRelation
 
       attr_reader :object, :relation_name
 
       def initialize(object, relation_name)
         @object, @relation_name = object, relation_name
-        super(object)
       end
 
-      def persisted?
-        object.nil? ? false : object.persisted?
+      def method_missing(method, *args, &block)
+        data.respond_to?(method) ? data.send(method, *args) : super
+      end
+
+      def data
+        object.get_internal_data(relation_name)
       end
 
     end

data/lib/smooth_operator/remote_call/base.rb

@@ -14,7 +14,6 @@ module SmoothOperator
         @response = response
       end
 
-
       def ok?
         http_status.between?(200, 299) || http_status == 304
       end
@@ -35,7 +34,6 @@ module SmoothOperator
         http_status.between?(500, 599) || http_status == 0
       end
 
-
       def not_found?
         http_status == 404
       end
@@ -48,12 +46,11 @@ module SmoothOperator
         false
       end
 
-
       def parsed_response
         return nil if body.nil?
-        
+
         require 'json' unless defined? JSON
-        
+
         begin
           JSON.parse(body)
         rescue JSON::ParserError
@@ -74,7 +71,5 @@ module SmoothOperator
       end
 
     end
-
   end
-
 end

data/lib/smooth_operator/translation.rb

@@ -1,27 +1,24 @@
 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/version.rb

@@ -1,3 +1,3 @@
 module SmoothOperator
-  VERSION = "1.2.1"
+  VERSION = "1.2.5"
 end

data/lib/smooth_operator.rb

@@ -25,4 +25,20 @@ module SmoothOperator
     end
 
   end
+
+  if defined?(ActiveModel)
+    class Rails < Base
+
+      include ActiveModel::Validations
+      include ActiveModel::Validations::Callbacks
+      include ActiveModel::Conversion
+
+      def column_for_attribute(attribute_name)
+        type = get_attribute_type(attribute_name)
+
+        ActiveRecord::ConnectionAdapters::Column.new(attribute_name.to_sym, type, type)
+      end
+
+    end
+  end
 end

data/spec/support/models/address.rb

@@ -10,5 +10,5 @@ class Address < SmoothOperator::Base
   self.endpoint = 'http://localhost:4567/'
 
   self.headers = { "X-APPTOKEN" => "joaquim_app_token", "X-LAYERTOKEN" => "joaquim_layer_token" }
-  
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smooth_operator
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.5
 platform: ruby
 authors:
 - João Gonçalves