smooth_operator 1.20.10 → 1.21.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NWVmZWM5OGI3M2I3NmM1MDA1NmQ4ODIzYTRlYzU1NjIzZDBiZDI1ZQ==
+    M2EyMTBiMWExYzQ4Mjc0ZDM3M2IyMGRkZmFjMTEzYmVjYzg5NDJkMw==
   data.tar.gz: !binary |-
-    ZjUxMTRlMDk0NDE1ZWI1ZWUwYTZhZWJhYWE3NzFmMmY0ZWEzYmQ2ZA==
+    YmZjYzA1YWM0ZjJmYzMwOWZjN2ZmMzVkMjRiNDFlYzc5MjVmYzNlNQ==
 SHA512:
   metadata.gz: !binary |-
-    YTFlYWU5MzJhMzZjZjk1MDdiOTlmNGYxNTkxMTJiOWJlYjg4MmZlMjVlYjU5
-    MDdhMGVjYjU2NDVjNWNkOTgzMjIwYzZhYzQ0ZGM2ZTQyYTY4ZDhmNmJmMTNm
-    MmFkNTBlMWM5MTBmZDU2Mjc2M2U1MWI0OTBhYmZmOTY2MWFkM2Q=
+    Mzg4ZGRhNDA4NWJjNmEzNDkzMWNjYjZhZTM5YTFiMGRiMmUzZWNmOWFmMzg4
+    NjFiMGVjMDJhZGRkNTExNzdhNTAzOTU4MjQxNmVmZTBiMzIxM2Q5Y2I5MzZh
+    MTlhYTZiYWYxNWU1OTZjZmM0YjQ0ZjFlMTYxMjIxZjE5NWMzMmE=
   data.tar.gz: !binary |-
-    YWI0ZTIxYjY5NjJhYThhYWEyZmJmZTQ1ZmQyMDJhMDY0NTUxNDc3ODkyMGI3
-    MzZiY2I2YjMzNGFjMzZmMDdkYmM2YTY0NWE1Mjg2ODYyY2RiMDc4YjY0ODM3
-    YjY1MTM1OGQ1MWE0OTA5NzBjMjA3OWRjMmQ1YmM5OTQyOTkwOWY=
+    ODljN2NlMTBlZDM1NWYwMzhlZmJjMDBkNDM3ZGEwOTYzZmNmZGFmNDQwMjUy
+    OWFhNjNmODRlNmUxYmI3MzdlZWQzZGEzZjg1MzE3ZmZkZDY2NmI5YjZiMDNj
+    OTdhNTA0OWNlMTk5NmM2OTNkZTlkZTlkODZhNDZiODhhNmVhZjc=

data/README.md

@@ -139,7 +139,7 @@ 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):
   remote_call.ok? # true
@@ -179,7 +179,7 @@ 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
+page = remote_call.data
 ```
 
 ---

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/attribute_assignment.rb

@@ -1,61 +1,18 @@
-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 = {})
       return nil unless _attributes.is_a?(Hash)
 
@@ -66,22 +23,22 @@ module SmoothOperator
         @_meta_data = _attributes
       end
 
-      options.each { |key, value| @_options[key] = value } if options.is_a?(Hash)
+      @_internal_errors = attributes.delete(self.class.errors_key)
 
-      attributes.each { |name, value| push_to_internal_data(name, value) }
-    end
+      options.each { |key, value| @_options[key] = value } if options.is_a? Hash
 
-    def parent_object
-      _options[:parent_object]
-    end
+      attributes.each do |name, value|
+        next unless allowed_attribute(name)
 
-    def has_data_from_server
-      _options[:from_server] == true
+        internal_data_push(name, value)
+      end
     end
 
-    alias :from_server :has_data_from_server
+    def _parent_object
+      _options[:parent_object]
+    end
 
-    protected #################### PROTECTED METHODS DOWN BELOW ######################
+    protected ################# PROTECTED METHODS DOWN BELOW ###################
 
     def before_initialize(attributes, options); end
 
@@ -97,5 +54,35 @@ module SmoothOperator
       end
     end
 
+    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
+
+    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,30 @@ 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
 
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
 
-    protected #################### PROTECTED ################
-
-    def parse_method(method)
-      method = method.to_s
+    module ClassMethods
 
-      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]
+      def strict_behaviour
+        Helpers.get_instance_variable(self, :strict_behaviour, false)
       end
-    end
 
+      attr_writer :strict_behaviour
 
-    private #################### PRIVATE ################
-
-    def method?(method, regex)
-      !! ((method.to_s) =~ regex)
     end
 
   end
-
 end

data/lib/smooth_operator/finder_methods.rb

@@ -1,43 +1,52 @@
 require 'smooth_operator/array_with_meta_data'
 
 module SmoothOperator
-  
   module FinderMethods
 
     def find(relative_path, data = {}, options = {})
       relative_path = '' if relative_path == :all
 
       get(relative_path, data, options) do |remote_call|
-        remote_call.object = build_object(remote_call.parsed_response, options) if remote_call.ok?
+        if remote_call.ok?
+          remote_call.object = HelperMethods
+            .build_object(self, remote_call.parsed_response, options)
+        end
 
         block_given? ? yield(remote_call) : remote_call
       end
     end
 
+    module HelperMethods
 
-    protected #################### PROTECTED ##################
+      extend self
 
-    def build_object(parsed_response, options, from_array = false)
-      if parsed_response.is_a?(Array)
-        parsed_response.map { |array_entry| build_object(array_entry, options, true) }
-      elsif parsed_response.is_a?(Hash)
-        if parsed_response.include?(object_class.resources_name) && !from_array
-          ArrayWithMetaData.new(parsed_response, object_class)
+      def build_object(object, parsed_response, options, from_array = false)
+        if parsed_response.is_a?(Array)
+          parse_array(parsed_response, object, options)
+        elsif parsed_response.is_a?(Hash)
+          parse_hash(object, parsed_response, options, from_array)
         else
-          object_class.new(parsed_response, from_server: true)
+          parsed_response
+        end
+      end
+
+      def parse_array(parsed_response, object, options)
+        parsed_response.map do |array_entry|
+          build_object(object, array_entry, options, true)
         end
-      else
-        parsed_response
       end
-    end
 
+      def parse_hash(object, parsed_response, options, from_array)
+        object_class ||= object.class == Class ? object : object.class
 
-    private #################### PRIVATE ##################
+        if parsed_response.include?(object_class.resources_name) && !from_array
+          ArrayWithMetaData.new(parsed_response.dup, object_class)
+        else
+          object_class.new(parsed_response, data_from_server: true)
+        end
+      end
 
-    def object_class
-      @object_class ||= self.class == Class ? self : self.class
     end
 
   end
-  
 end

data/lib/smooth_operator/helpers.rb

@@ -4,16 +4,18 @@ module SmoothOperator
 
     extend self
 
-    def safe_call(object, method, *args)
-      if object.respond_to?(method)
-        object.send(method, *args)
-      else
-        false
-      end
+    def primary_key(object)
+      object.internal_data_get(object.class.primary_key)
+    end
+
+    def has_primary_key?(object)
+      blank? primary_key(object)
     end
 
     def super_method(object, method_name, *args)
-      object.superclass.send(method_name, *args) if object.superclass.respond_to?(method_name)
+      if object.superclass.respond_to?(method_name)
+        object.superclass.send(method_name, *args)
+      end
     end
 
     def get_instance_variable(object, variable, default_value)
@@ -56,7 +58,7 @@ module SmoothOperator
       case object
       when String
         object.to_s == ''
-      when Array
+      when Array, Hash
         object.empty?
       else
         object.nil?

data/lib/smooth_operator/internal_data.rb

@@ -0,0 +1,45 @@
+require 'smooth_operator/type_casting'
+
+module SmoothOperator
+  module InternalData
+
+    def internal_data
+      @internal_data ||= {}
+    end
+
+    def known_attributes
+      return @known_attributes if defined?(@known_attributes)
+
+      schema_attributes = if self.class.respond_to?(:internal_structure)
+        self.class.internal_structure.keys
+      else
+        []
+      end
+
+      @known_attributes = Set.new(schema_attributes)
+    end
+
+    def known_attribute?(attribute)
+      known_attributes.include?(attribute.to_s)
+    end
+
+    def internal_data_get(attribute_name)
+      internal_data[attribute_name]
+    end
+
+    def internal_data_push(attribute_name, attribute_value)
+      attribute_name = attribute_name.to_s
+
+      known_attributes.add attribute_name
+
+      internal_data[attribute_name] = TypeCasting.cast_to_type(attribute_name, attribute_value, self)
+
+      if self.class.respond_to?(:smooth_operator?)
+        marked_for_destruction?(attribute_value) if attribute_name == self.class.destroy_key
+
+        new_record?(true) if attribute_name == self.class.primary_key
+      end
+    end
+
+  end
+end

data/lib/smooth_operator/open_struct.rb

@@ -1,38 +1,20 @@
-require "smooth_operator/model_name"
 require "smooth_operator/delegation"
 require "smooth_operator/validations"
+require "smooth_operator/resource_name"
 require "smooth_operator/serialization"
-require "smooth_operator/attribute_methods"
+require "smooth_operator/internal_data"
 require "smooth_operator/attribute_assignment"
 
 module SmoothOperator
-  module OpenStruct
+  class OpenStruct
 
-    class Base
+    extend ResourceName
 
-      extend ModelName
-
-      include Delegation
-      include Validations
-      include Serialization
-      include AttributeMethods
-      include AttributeAssignment
-
-      def self.strict_behaviour=(value)
-        @strict_behaviour = value
-      end
-
-      def self.strict_behaviour
-        Helpers.get_instance_variable(self, :strict_behaviour, false)
-      end
-
-    end
-
-    class Dirty < Base
-
-      dirty_attributes
-
-    end
+    include Delegation
+    include Validations
+    include InternalData
+    include Serialization
+    include AttributeAssignment
 
   end
 end