smooth_operator 1.3.0 → 1.8.0

data/lib/smooth_operator/array_with_meta_data.rb

@@ -1,35 +1,36 @@
 module SmoothOperator
-  class ArrayWithMetaData < SimpleDelegator
 
-    attr_reader :meta_data, :internal_array
+  class ArrayWithMetaData < OpenStruct
+    
+    extend Forwardable
 
-    def initialize(attributes, object_class)
-      resources_name = object_class.resources_name
+    include Enumerable
 
-      @internal_array = [*attributes[resources_name]].map do |array_entry|
-        object_class.new(array_entry)
-      end
+    attr_reader :meta_data, :internal_array, :table_name, :object_class
 
-      attributes.delete(resources_name)
+    def_delegators :internal_array, :length, :<<
 
-      @meta_data = attributes
+    def initialize(attributes, table_name, object_class)
+      _attributes = attributes.dup
 
-      define_metada_methods
+      @table_name, @object_class = table_name, object_class
 
-      super(@internal_array)
+      @internal_array = [*_attributes[table_name]].map { |array_entry| object_class.new(array_entry) }
+      _attributes.delete(table_name)
+
+      @meta_data = _attributes
     end
 
-    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
+    def each
+      internal_array.each { |array_entry| yield array_entry }
+    end
+    
+    def method_missing(method, *args, &block)
+      _method = method.to_s
+      meta_data.include?(_method) ? meta_data[_method] : super
     end
 
   end
+
 end

data/lib/smooth_operator/attribute_assignment.rb

@@ -1,55 +1,78 @@
+require 'smooth_operator/internal_attribute'
+
 module SmoothOperator
+
   module AttributeAssignment
 
-    def initialize(attributes = {}, options = {})
-      @_options = {}
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
 
-      before_initialize(attributes, options)
+    module ClassMethods
 
-      assign_attributes(attributes, options)
+      attr_accessor :turn_unknown_hash_to_open_struct
 
-      after_initialize(attributes, options)
-    end
+      def attributes_white_list
+        Helpers.get_instance_variable(self, :attributes_white_list, Set.new)
+      end
 
-    attr_reader :_options, :_meta_data
+      def attributes_black_list
+        Helpers.get_instance_variable(self, :attributes_black_list, Set.new)
+      end
 
-    def assign_attributes(attributes = {}, options = {})
-      attributes = _extract_attributes(attributes)
+      def attributes_white_list_add(*getters)
+        attributes_white_list.merge getters.map(&:to_s)
+      end
 
-      return nil unless attributes.is_a?(Hash)
+      def attributes_black_list_add(*getters)
+        attributes_black_list.merge getters.map(&:to_s)
+      end
 
-      induce_errors(attributes.delete(self.class.errors_key))
+    end
 
-      @_options.merge!(options) if options.is_a? Hash
 
-      attributes.each do |name, value|
-        next unless allowed_attribute(name)
+    def initialize(attributes = {})
+      before_initialize(attributes)
 
-        send("#{name}=", value)
-      end
-    end
+      assign_attributes attributes
 
-    protected ################# PROTECTED METHODS DOWN BELOW ###################
+      after_initialize(attributes)
+    end
 
-    def _extract_attributes(attributes)
+    def assign_attributes(attributes = {})
       return nil unless attributes.is_a?(Hash)
+      
+      attributes.each { |name, value| push_to_internal_data(name, value) }
+    end
+
+    def internal_data
+      @internal_data ||= {}
+    end
+
+    def get_internal_data(field, method = :value)
+      internal_data[field].nil? ? nil : internal_data[field].send(method)
+    end
 
-      _attributes = Helpers.stringify_keys(attributes)
+    def push_to_internal_data(attribute_name, attribute_value)
+      attribute_name = attribute_name.to_s
 
-      if _attributes.include?(self.class.resource_name)
-        attributes = _attributes.delete(self.class.resource_name)
-        @_meta_data = _attributes
+      return nil unless allowed_attribute(attribute_name)
+      
+      known_attributes.add attribute_name
+      
+      if internal_data[attribute_name].nil?
+        internal_data[attribute_name] = InternalAttribute.new(attribute_name, attribute_value, internal_structure[attribute_name], self.class.turn_unknown_hash_to_open_struct)
       else
-        attributes = _attributes
-        @_meta_data = {}
+        internal_data[attribute_name].set_value(attribute_value)
       end
-
-      attributes
     end
 
-    def before_initialize(attributes, options); end
+    
+    protected #################### PROTECTED METHODS DOWN BELOW ######################
+
+    def before_initialize(attributes); end
 
-    def after_initialize(attributes, options); end
+    def after_initialize(attributes); end
 
     def allowed_attribute(attribute)
       if !self.class.attributes_white_list.empty?
@@ -61,33 +84,6 @@ 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/delegation.rb

@@ -1,33 +1,52 @@
 module SmoothOperator
+
   module Delegation
 
-    def respond_to?(method, include_private = false)
-      known_attribute?(method) ? true : super
+    def respond_to?(method)
+      known_attributes.include?(method.to_s) ? true : super
     end
 
     def method_missing(method, *args, &block)
-      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)
+      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)
       else
-        super
+        return get_internal_data(method_name) if respond_to?(method_name)
       end
-    end
 
-    def self.included(base)
-      base.extend(ClassMethods)
+      result.nil? ? super : result
     end
 
-    module ClassMethods
 
-      def strict_behaviour
-        get_option :strict_behaviour, false
+    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
+    end
+
 
+    private #################### PRIVATE ################
+
+    def method?(method, regex)
+      !! ((method.to_s) =~ regex)
     end
 
   end
+
 end

data/lib/smooth_operator/finder_methods.rb

@@ -1,52 +1,36 @@
 require 'smooth_operator/array_with_meta_data'
 
 module SmoothOperator
+  
   module FinderMethods
 
+    def all(data = {}, options = {})
+      find(:all, data, options)
+    end
+
     def find(relative_path, data = {}, options = {})
       relative_path = '' if relative_path == :all
 
-      get(relative_path, data, options) do |remote_call|
-        if remote_call.ok?
-          remote_call.object = HelperMethods
-            .build_object(self, remote_call.parsed_response, options)
-        end
-
-        block_given? ? yield(remote_call) : remote_call
+      get(relative_path, data, options).tap do |remote_call|
+        remote_call.object = build_object(remote_call.parsed_response, options)
       end
     end
 
-    module HelperMethods
-
-      extend self
 
-      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
-          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
-      end
+    protected #################### PROTECTED ##################
 
-      def parse_hash(object, parsed_response, options, from_array)
-        object_class ||= object.class == Class ? object : object.class
+    def build_object(parsed_response, options)
+      table_name = (options[:table_name] || self.table_name).to_s
 
-        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
+      if parsed_response.is_a?(Array)
+        parsed_response.map { |array_entry| build_object(array_entry, options) }
+      elsif parsed_response.is_a?(Hash)
+        parsed_response.include?(table_name) ? ArrayWithMetaData.new(parsed_response, table_name, self) : new(parsed_response)
+      else
+        parsed_response
       end
-
     end
 
   end
+  
 end

data/lib/smooth_operator/helpers.rb

@@ -3,23 +3,9 @@ module SmoothOperator
   module Helpers
 
     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
-
-    def has_primary_key?(object)
-      blank? primary_key(object)
-    end
-
+    
     def super_method(object, method_name, *args)
-      if object.superclass.respond_to?(method_name)
-        object.superclass.send(method_name, *args)
-      end
+      object.superclass.send(method_name, *args) if object.superclass.respond_to?(method_name)
     end
 
     def get_instance_variable(object, variable, default_value)
@@ -27,12 +13,8 @@ module SmoothOperator
 
       return instance_var unless instance_var.nil?
 
-      instance_var = (super_method(object, variable) || default_value)
-
-      if instance_var.class == Class
+      (super_method(object, variable) || default_value).dup.tap do |instance_var|
         object.instance_variable_set("@#{variable}", instance_var)
-      else
-        object.instance_variable_set("@#{variable}", duplicate(instance_var))
       end
     end
 
@@ -49,11 +31,6 @@ module SmoothOperator
       end
     end
 
-    def plural?(string)
-      string = string.to_s
-      string == string.pluralize
-    end
-
     def duplicate(object)
       object.dup rescue object
     end
@@ -62,7 +39,7 @@ module SmoothOperator
       case object
       when String
         object.to_s == ''
-      when Array, Hash
+      when Array
         object.empty?
       else
         object.nil?
@@ -72,14 +49,7 @@ module SmoothOperator
     def present?(object)
       !blank?(object)
     end
-
-    def absolute_path?(string)
-      present?(string) && string[0] == '/'
-    end
-
-    def remove_initial_slash(string)
-      string[1..-1]
-    end
-
+    
   end
-end
+  
+end

data/lib/smooth_operator/internal_attribute.rb

@@ -0,0 +1,49 @@
+require 'smooth_operator/type_converter'
+
+module SmoothOperator
+
+  class InternalAttribute
+
+    attr_reader :original_name, :original_value, :first_value, :value, :type, :turn_unknown_hash_to_open_struct
+
+    def initialize(name, value, type, turn_to_open_struct = nil)
+      @original_name, @original_value, @type = name, value, type
+      
+      @turn_unknown_hash_to_open_struct = turn_to_open_struct.nil? ? true : turn_to_open_struct
+
+      @first_value = set_value(value)
+    end
+
+    def set_value(new_value)
+      @value = cast_to_type(new_value)
+    end
+
+    def changed?
+      @first_value != @value
+    end
+
+    def was
+      @first_value
+    end
+
+
+    protected ######################## PROTECTED #####################
+
+    def cast_to_type(_value)
+      case _value
+      when Array
+        _value.map { |array_entry| InternalAttribute.new(original_name, array_entry, type, turn_unknown_hash_to_open_struct).value }
+      when Hash
+        if turn_unknown_hash_to_open_struct
+          (type || OpenStruct).new(_value)
+        else
+          type.nil? ? _value : type.new(_value)
+        end
+      else
+        TypeConverter.convert(_value, type)
+      end
+    end
+
+  end
+
+end