smooth_operator 1.2.9 → 1.3.0

data/lib/smooth_operator/persistence.rb

@@ -7,28 +7,20 @@ module SmoothOperator
 
     attr_reader :last_remote_call
 
-    def get_primary_key
-      get_internal_data(self.class.primary_key)
-    end
-
-    def reload(relative_path = nil, data = {}, options = {})
-      raise 'UnknownPath' if Helpers.blank?(relative_path) && (!respond_to?(self.class.primary_key) || Helpers.blank?(get_primary_key))
+    def new_record?(ignore_cache = false)
+      return @new_record if !ignore_cache && defined?(@new_record)
 
-      persistence_call(:reload, relative_path, data, options) do |remote_call|
-        block_given? ? yield(remote_call) : remote_call.status
-      end
+      @new_record = Helpers.has_primary_key?(self)
     end
 
-    def new_record?(bypass_cache = false)
-      return @new_record if !bypass_cache && defined?(@new_record)
-
-      @new_record = Helpers.blank?(get_primary_key)
-    end
+    def marked_for_destruction?(ignore_cache = false)
+      if !ignore_cache && defined?(@marked_for_destruction)
+        return @marked_for_destruction
+      end
 
-    def marked_for_destruction?(bypass_cache = false)
-      return @marked_for_destruction if !bypass_cache && defined?(@marked_for_destruction)
+      _destroy = internal_data_get(self.class.destroy_key)
 
-      @marked_for_destruction = ["true", "1", true].include?(get_internal_data(self.class.destroy_key))
+      @marked_for_destruction = TypeCasting::TRUE_VALUES.include?(_destroy)
     end
 
     def destroyed?
@@ -41,102 +33,113 @@ module SmoothOperator
       !(new_record? || destroyed?)
     end
 
-    def save(relative_path = nil, data = {}, options = {})
-      data = data_with_object_attributes(data, options)
+    def known_attribute?(attribute)
+      super ||
+      [self.class.primary_key, self.class.destroy_key].include?(attribute.to_s)
+    end
 
-      if new_record?
-        create(relative_path, data, options) { |remote_call| block_given? ? yield(remote_call) : remote_call.status }
-      else
-        update(relative_path, data, options) { |remote_call| block_given? ? yield(remote_call) : remote_call.status }
+    def reload(relative_path = nil, data = {}, options = {})
+      if Helpers.blank?(relative_path) && Helpers.has_primary_key?(self)
+        raise 'UnknownPath'
+      end
+
+      make_a_persistence_call(:reload, relative_path, data, options) do |remote_call|
+        block_given? ? yield(remote_call) : remote_call.status
       end
     end
 
-    def save!(relative_path = nil, data = {}, options = {})
-      save(relative_path, data, options) do |remote_call|
+    def save(relative_path = nil, data = {}, options = {})
+      resource_data = resource_data_for_server(data)
+
+      method = new_record? ? :create : :update
+
+      make_a_persistence_call(method, relative_path, resource_data, options) do |remote_call|
+        @new_record = false if method == :create && remote_call.status
+
         block_given? ? yield(remote_call) : remote_call.status
-      end || raise('RecordNotSaved')
+      end
     end
 
     def destroy(relative_path = nil, data = {}, options = {})
       return false unless persisted?
 
-      persistence_call(:destroy, relative_path, data, options) do |remote_call|
+      make_a_persistence_call(:destroy, relative_path, data, options) do |remote_call|
         @destroyed = true if remote_call.status
 
         block_given? ? yield(remote_call) : remote_call.status
       end
     end
 
+    def save!(relative_path = nil, data = {}, options = {})
+      save(relative_path, data, options) do |remote_call|
+        block_given? ? yield(remote_call) : remote_call.status
+      end || raise('RecordNotSaved')
+    end
 
     protected ######################### PROTECTED ##################
 
-    def create(relative_path, data, options)
-      persistence_call(:create, relative_path, data, options) do |remote_call|
-        @new_record = false if remote_call.status
+    def internal_data_for_server
+      data = self.class.get_option(:internal_data_for_server, false)
 
-        block_given? ? yield(remote_call) : remote_call
+      if data == false
+        serializable_hash.dup.tap { |hash| hash.delete(self.class.primary_key) }
+      else
+        data
       end
     end
 
-    def update(relative_path, data, options)
-      persistence_call(:update, relative_path, data, options) do |remote_call|
-        block_given? ? yield(remote_call) : remote_call
+    def resource_data_for_server(data)
+      resource_data =
+        self.class.get_option(:resource_data_for_server, false, data)
+
+      if resource_data == false
+        data = Helpers.stringify_keys(data)
+        resource_data = Helpers.stringify_keys(internal_data_for_server)
+
+        { self.class.resource_name.to_s => resource_data }.merge(data)
+      else
+        resource_data
       end
     end
 
-    def persistence_call(method, relative_path, data, options)
+    private ##################### PRIVATE ##################
+
+    def make_a_persistence_call(method, relative_path, data, options)
       options ||= {}
 
-      http_verb = options[:http_verb] || self.class.methods_vs_http_verbs[method]
+      http_verb = options[:http_verb] || self.class.http_verb_for(method)
 
       make_the_call(http_verb, relative_path, data, options) do |remote_call|
         @last_remote_call = remote_call
 
         if !@last_remote_call.error? && @last_remote_call.parsed_response.is_a?(Hash)
-          assign_attributes @last_remote_call.parsed_response, from_server: true
+          assign_attributes @last_remote_call.parsed_response, data_from_server: true
         end
 
         yield(remote_call)
       end
     end
 
-    def data_with_object_attributes(data, options)
-      data = Helpers.stringify_keys(data)
-
-      hash = serializable_hash(options[:serializable_options]).dup
-
-      hash.delete(self.class.primary_key)
-
-      { self.class.resource_name => hash }.merge(data)
-    end
-
-
     module ClassMethods
 
       METHODS_VS_HTTP_VERBS = { reload: :get, create: :post, update: :put, destroy: :delete }
 
-      def methods_vs_http_verbs
-        Helpers.get_instance_variable(self, :methods_vs_http_verbs, METHODS_VS_HTTP_VERBS.dup)
+      def http_verb_for(method)
+        get_option "#{method}_http_verb".to_sym, METHODS_VS_HTTP_VERBS[method]
       end
 
       def primary_key
-        Helpers.get_instance_variable(self, :primary_key, 'id')
+        get_option :primary_key, 'id'
       end
 
-      attr_writer :primary_key
-
       def destroy_key
-        Helpers.get_instance_variable(self, :destroy_key, '_destroy')
-      end
-
-      attr_writer :destroy_key
-
-      METHODS_VS_HTTP_VERBS.keys.each do |method|
-        define_method("#{method}_http_verb=") { |http_verb| methods_vs_http_verbs[method] = http_verb }
+        get_option :destroy_key, '_destroy'
       end
 
       def create(attributes = nil, relative_path = nil, data = {}, options = {})
-        new(attributes).tap { |object| object.save(relative_path, data, options) }
+        new(attributes).tap do |object|
+          object.save(relative_path, data, options)
+        end
       end
 
     end

data/lib/smooth_operator/remote_call/base.rb

@@ -1,5 +1,6 @@
-module SmoothOperator
+require "smooth_operator/cookie_jar"
 
+module SmoothOperator
   module RemoteCall
 
     class Base
@@ -54,7 +55,7 @@ module SmoothOperator
         begin
           JSON.parse(body)
         rescue JSON::ParserError
-          nil
+          body
         end
       end
 
@@ -62,14 +63,14 @@ module SmoothOperator
         error? ? nil : ok?
       end
 
-      def objects
-        object.respond_to?(:length) ? object : []
-      end
-
       def data
         object.nil? ? parsed_response : object
       end
 
+      def cookie(header_field = 'set-cookie')
+        CookieJar.new.parse(headers[header_field])
+      end
+
     end
   end
 end

data/lib/smooth_operator/resource_name.rb

@@ -0,0 +1,46 @@
+module SmoothOperator
+  module ResourceName
+
+    def resources_name
+      get_option :resources_name, self.resource_name.pluralize
+    end
+
+    def resource_name
+      get_option :resource_name, self.model_name.to_s.underscore
+    end
+
+    def model_name
+      return '' if custom_model_name == :none
+
+      if defined? ActiveModel
+        smooth_model_name
+      else
+        custom_model_name ||= name.split('::').last.underscore.capitalize
+      end
+    end
+
+    def model_name=(name)
+      @custom_model_name = name
+    end
+
+    def custom_model_name
+      Helpers.get_instance_variable(self, :custom_model_name, nil)
+    end
+
+    protected ############## PROTECTED #############
+
+    def smooth_model_name
+      @_model_name ||= begin
+        namespace ||= self.parents.detect do |n|
+          n.respond_to?(:use_relative_model_naming?) && n.use_relative_model_naming?
+        end
+
+        ActiveModel::Name.new(self, namespace, custom_model_name).tap do |model_name|
+          def model_name.human(options = {}); SmoothOperator::Translation::HelperMethods.translate("models.#{i18n_key}", options); end
+        end
+      end
+    end
+
+  end
+
+end

data/lib/smooth_operator/schema.rb

@@ -0,0 +1,21 @@
+module SmoothOperator
+  module Schema
+
+    def schema(structure)
+      internal_structure.merge! Helpers.stringify_keys(structure)
+    end
+
+    def internal_structure
+      Helpers.get_instance_variable(self, :internal_structure, {})
+    end
+
+    def known_attribute?(attribute)
+      internal_structure.has_key?(attribute.to_s)
+    end
+
+    def attribute_type(attribute)
+      internal_structure[attribute.to_s]
+    end
+
+  end
+end

data/lib/smooth_operator/serialization.rb

@@ -5,13 +5,12 @@ module SmoothOperator
     def to_hash(options = nil)
       Helpers.symbolyze_keys(serializable_hash(options) || {})
     end
-    
-    # alias :attributes :to_hash
+
     def attributes; to_hash; end
-    
+
     def to_json(options = nil)
       require 'json' unless defined? JSON
-      
+
       JSON(serializable_hash(options) || {})
     end
 
@@ -22,58 +21,103 @@ 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.each do |attribute_name|
+        attribute_name, attribute_value = HelperMethods
+          .serialize_normal_or_rails_way(self, attribute_name, options)
 
-      attribute_names(options).each do |attribute_name|
-        hash[attribute_name] = read_attribute_for_hashing(attribute_name, options)
+        hash[attribute_name] = attribute_value
       end
 
-      method_names(options).each do |method_name|
-        hash[method_name.to_s] = send(method_name)
+      method_names.each do |method_name|
+        hash[method_name.to_s] = HelperMethods.serialize_normal_attribute(send(method_name), method_name, options[method_name])
       end
 
       hash
     end
 
+    module HelperMethods
+
+      extend self
+
+      def attribute_names(object, options)
+        attribute_names = object.internal_data.keys.sort
+
+        if only = options[:only]
+          white_list = [*only].map(&:to_s)
 
-    protected ##################### PROTECTED ###################
-    
-    # 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.respond_to?(:reflect_on_association) &&
+          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)
+        if parent_object.respond_to?(:read_attribute_for_serialization)
+          object = parent_object.read_attribute_for_serialization(attribute_name)
+        else
+          object = parent_object
+        end
+
+        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/translation.rb

@@ -2,23 +2,32 @@ module SmoothOperator
   module Translation
 
     def human_attribute_name(attribute_key_name, options = {})
-      _translate("attributes.#{model_name.i18n_key}.#{attribute_key_name}", options = {})
+      HelperMethods.translate(
+        "attributes.#{model_name.i18n_key}.#{attribute_key_name}",
+        options
+      )
     end
 
-    private ###################### PRIVATE #########################
+    module HelperMethods
 
-    def _translate(namespace = '', options = {})
-      no_translation = "-- no translation --"
+      extend self
 
-      defaults = ["smooth_operator.#{namespace}".to_sym]
-      defaults << "activerecord.#{namespace}".to_sym
-      defaults << options[:default] if options[:default]
-      defaults.flatten!
-      defaults << no_translation
+      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
 
-      options = { count: 1, default: defaults }.merge!(options.except(:default))
-      I18n.translate(defaults.shift, options)
     end
 
   end
-end
+end

data/lib/smooth_operator/type_casting.rb

@@ -0,0 +1,127 @@
+module SmoothOperator
+  module TypeCasting
+
+    # RIPPED FROM RAILS
+    TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE', 'on', 'ON'].to_set
+    FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off', 'OFF'].to_set
+
+    extend self
+
+    def cast_to_type(name, value, parent_object)
+      type, known_attribute, unknown_hash_class = extract_args(parent_object.class, name)
+
+      return Helpers.duplicate(value) if known_attribute && type.nil?
+
+      case value
+      when Array
+        value.map { |array_entry| cast_to_type(name, array_entry, parent_object) }
+      when Hash
+        type.nil? ? new_unknown_hash(value, unknown_hash_class, parent_object) : type.new(value, parent_object: parent_object)
+      else
+        convert(value, type)
+      end
+    end
+
+    protected ##################### PROTECTED ########################
+
+    def extract_args(parent_object_class, name)
+      known_attribute, attribute_type = false, false
+
+      if parent_object_class.respond_to?(:known_attribute?)
+        known_attribute = parent_object_class.known_attribute?(name)
+      end
+
+      if parent_object_class.respond_to?(:attribute_type)
+        attribute_type = parent_object_class.attribute_type(name)
+      end
+
+      [
+        attribute_type,
+        known_attribute,
+        parent_object_class.unknown_hash_class
+      ]
+    end
+
+    def convert(value, type)
+      case type
+
+      when :string, :text, String
+        value.to_s
+
+      when :int, :integer, Integer, Fixnum
+        to_int(value)
+
+      when :date, Date
+        to_date(value)
+
+      when :float, Float
+        to_float(value)
+
+      when :bool, :boolean
+        to_boolean(value)
+
+      when :datetime, :date_time, DateTime
+        to_datetime(value)
+
+      else
+        Helpers.duplicate(value)
+      end
+    end
+
+    def to_date(string)
+      return string if string.is_a?(Date)
+
+      Date.parse(string) rescue nil
+    end
+
+    def to_datetime(string)
+      return string if string.is_a?(DateTime)
+
+      DateTime.parse(string) rescue nil
+    end
+
+    def to_boolean(string)
+      value = string.to_s.downcase
+
+      TRUE_VALUES.include?(value) ? true : FALSE_VALUES.include?(value) ? false : nil
+    end
+
+    def to_int(string)
+      return string if string.is_a?(Fixnum)
+
+      to_float(string).to_i
+    end
+
+    def to_float(string)
+      return string if string.is_a?(Float)
+
+      return 0 if string.nil? || !(string.is_a?(String) || string.is_a?(Fixnum))
+
+      value = string.to_s.gsub(',', '.').scan(/-*\d+[.]*\d*/).flatten.map(&:to_f).first
+
+      value.nil? ? 0 : value
+    end
+
+    def new_unknown_hash(hash, unknown_hash_class, parent_object)
+      if unknown_hash_class.nil?
+        hash
+      else
+        unknown_hash_class.new(cast_params(hash, unknown_hash_class, parent_object))
+      end
+    end
+
+    private ################### PRIVATE #####################
+
+    def cast_params(attributes, unknown_hash_class, parent_object)
+      hash = {}
+
+      attributes.each do |key, value|
+        hash[key] = cast_to_type(key, value, parent_object)
+      end
+
+      hash
+    end
+
+  end
+
+end

data/lib/smooth_operator/validations.rb

@@ -1,15 +1,37 @@
 module SmoothOperator
-
   module Validations
 
     def valid?(context = nil)
-      Helpers.blank?(get_internal_data("errors"))
+      Helpers.blank?(induced_errors)
     end
 
     def invalid?
       !valid?
     end
 
-  end
+    def induced_errors
+      @induced_errors ||= {}
+    end
+
+    def clear_induced_errors
+      @induced_errors = {}
+    end
+
+    def induce_errors(value)
+      @induced_errors = value
+    end
 
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+
+      def errors_key
+        get_option :errors_key, 'errors'
+      end
+
+    end
+
+  end
 end

data/lib/smooth_operator/version.rb

@@ -1,3 +1,3 @@
 module SmoothOperator
-  VERSION = "1.2.9"
+  VERSION = '1.3.0'
 end