smooth_operator 1.20.10 → 1.21.0

data/lib/smooth_operator/operator.rb

@@ -12,8 +12,10 @@ module SmoothOperator
 
       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}"
+      if !_parent_object.nil? && options[:ignore_parent] != true
+        id = Helpers.primary_key(_parent_object)
+
+        options[:resources_name] ||= "#{_parent_object.class.resources_name}/#{id}/#{self.class.resources_name}"
       end
 
       self.class.make_the_call(http_verb, relative_path, data, options) do |remote_call|
@@ -27,12 +29,18 @@ module SmoothOperator
       if Helpers.absolute_path?(relative_path)
         Helpers.remove_initial_slash(relative_path)
       elsif persisted?
-        Helpers.present?(relative_path) ? "#{get_primary_key}/#{relative_path}" : get_primary_key.to_s
+        id = Helpers.primary_key(self)
+
+        Helpers.present?(relative_path) ? "#{id}/#{relative_path}" : id.to_s
       else
         relative_path
       end
     end
 
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
     ########################### MODULES BELLOW ###############################
 
     module HttpMethods
@@ -67,7 +75,6 @@ module SmoothOperator
 
       attr_writer :headers
 
-
       def make_the_call(http_verb, relative_path = '', data = {}, options = {})
         operator_args = operator_method_args(http_verb, relative_path, data, options)
 
@@ -127,13 +134,5 @@ module SmoothOperator
       end
     end
 
-    include HttpMethods
-
-    def self.included(base)
-      base.extend(ClassMethods)
-      base.extend(HttpMethods)
-    end
-
   end
-
 end

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,13 +33,28 @@ module SmoothOperator
       !(new_record? || destroyed?)
     end
 
+    def known_attribute?(attribute)
+      super ||
+      [self.class.primary_key, self.class.destroy_key].include?(attribute.to_s)
+    end
+
+    def reload(relative_path = nil, data = {}, options = {})
+      if Helpers.blank?(relative_path) && Helpers.has_primary_key?(self)
+        raise 'UnknownPath'
+      end
+
+      _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 = {})
-      data = data_with_object_attributes(data, options)
+      data = resource_attributes(data, options)
+
+      method = new_record? ? :create : :update
 
-      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 }
+      send(method, relative_path, data, options) do |remote_call|
+        block_given? ? yield(remote_call) : remote_call.status
       end
     end
 
@@ -60,18 +67,17 @@ module SmoothOperator
     def destroy(relative_path = nil, data = {}, options = {})
       return false unless persisted?
 
-      persistence_call(:destroy, relative_path, data, options) do |remote_call|
+      _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
 
-
     protected ######################### PROTECTED ##################
 
     def create(relative_path, data, options)
-      persistence_call(:create, relative_path, data, options) do |remote_call|
+      _persistence_call(:create, relative_path, data, options) do |remote_call|
         @new_record = false if remote_call.status
 
         block_given? ? yield(remote_call) : remote_call
@@ -79,12 +85,24 @@ module SmoothOperator
     end
 
     def update(relative_path, data, options)
-      persistence_call(:update, relative_path, data, options) do |remote_call|
+      _persistence_call(:update, relative_path, data, options) do |remote_call|
         block_given? ? yield(remote_call) : remote_call
       end
     end
 
-    def persistence_call(method, relative_path, data, options)
+    def resource_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
+
+    private ##################### PRIVATE ##################
+
+    def _persistence_call(method, relative_path, data, options)
       options ||= {}
 
       http_verb = options[:http_verb] || self.class.methods_vs_http_verbs[method]
@@ -93,24 +111,13 @@ module SmoothOperator
         @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 }
@@ -132,11 +139,15 @@ module SmoothOperator
       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 }
+        define_method("#{method}_http_verb=") do |http_verb|
+          methods_vs_http_verbs[method] = http_verb
+        end
       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/relation/array_relation.rb

@@ -1,6 +1,6 @@
 module SmoothOperator
   module Relation
-    class ArrayRelation < ::SimpleDelegator
+    class ArrayRelation < SimpleDelegator
 
       attr_reader :object, :association
 
@@ -30,18 +30,8 @@ module SmoothOperator
 
       protected ############### PROTECTED ###############
 
-      # def method_missing(method, *args, &block)
-      #   if get_array.respond_to?(method)
-      #     puts "if true #{method} - #{args}"
-      #     get_array.send(method, *args)
-      #   else
-      #     puts "if else #{method}"
-      #     super
-      #   end
-      # end
-
       def get_array
-        data = object.get_internal_data(association.to_s)
+        data = object.internal_data_get(association.to_s)
 
         data.nil? ? [] : [*data]
       end

data/lib/smooth_operator/relation/association_reflection.rb

@@ -8,8 +8,8 @@ module SmoothOperator
 
       def initialize(association, related_reflection, options)
         super(association, options)
-        @macro = options[:macro] || macro_default(association)
-        @related_reflection = related_reflection
+
+        @related_reflection, @macro = related_reflection, options[:macro]
       end
 
       def primary_key
@@ -62,10 +62,6 @@ module SmoothOperator
 
       private ################################# private
 
-      def macro_default(association)
-        Helpers.plural?(association) ? :has_many : :belongs_to
-      end
-
       def foreign_key_default
         if has_many? || has_one?
           "#{related_reflection.single_name}_id"

data/lib/smooth_operator/relation/associations.rb

@@ -70,12 +70,12 @@ module SmoothOperator
       end
 
       def define_single_association_method(reflection, association)
-        define_method(association) { get_internal_data(association.to_s) }
+        define_method(association) { internal_data_get(association.to_s) }
 
         define_method("build_#{association}") do |attributes = {}|
           new_instance = reflection.klass.new(attributes)
 
-          push_to_internal_data(association, new_instance)
+          internal_data_push(association, new_instance)
 
           new_instance
         end
@@ -87,7 +87,7 @@ module SmoothOperator
 
           attributes = attributes.values if reflection.has_many?
 
-          push_to_internal_data(association.to_s, attributes)
+          internal_data_push(association.to_s, attributes)
         end
       end
 

data/lib/smooth_operator/remote_call/base.rb

@@ -62,10 +62,6 @@ module SmoothOperator
         error? ? nil : ok?
       end
 
-      def objects
-        object.respond_to?(:length) ? object : []
-      end
-
       def data
         object.nil? ? parsed_response : object
       end

data/lib/smooth_operator/{model_name.rb → resource_name.rb}

@@ -1,5 +1,5 @@
 module SmoothOperator
-  module ModelName
+  module ResourceName
 
     def resources_name(default_bypass = nil)
       return @resources_name if defined?(@resources_name)
@@ -40,7 +40,7 @@ module SmoothOperator
         end
 
         ActiveModel::Name.new(self, namespace, @_model_name).tap do |model_name|
-          def model_name.human(options = {}); @klass.send(:_translate, "models.#{i18n_key}", options); end
+          def model_name.human(options = {}); SmoothOperator::Translation::HelperMethods.translate("models.#{i18n_key}", options); end
         end
       end
     end

data/lib/smooth_operator/schema.rb

@@ -1,32 +1,21 @@
 module SmoothOperator
   module Schema
 
-    def known_by_schema?(attribute)
-      self.class.internal_structure.include?(attribute.to_s)
+    def schema(structure)
+      internal_structure.merge! Helpers.stringify_keys(structure)
     end
 
-    def get_attribute_type(attribute)
-      self.class.internal_structure[attribute.to_s]
+    def internal_structure
+      Helpers.get_instance_variable(self, :internal_structure,
+        { primary_key => nil })
     end
 
-    def self.included(base)
-      base.extend(ClassMethods)
+    def known_attribute?(attribute)
+      internal_structure.has_key?(attribute.to_s)
     end
 
-    module ClassMethods
-
-      attr_writer :resource_name
-
-      def schema(structure)
-        internal_structure.merge! Helpers.stringify_keys(structure)
-
-        known_attributes.merge internal_structure.keys
-      end
-
-      def internal_structure
-        Helpers.get_instance_variable(self, :internal_structure, { "errors" => nil, primary_key => nil, destroy_key => nil })
-      end
-
+    def attribute_type(attribute)
+      internal_structure[attribute.to_s]
     end
 
   end

data/lib/smooth_operator/serialization.rb

@@ -5,13 +5,13 @@ 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
 
@@ -23,8 +23,8 @@ module SmoothOperator
       hash = {}
       options ||= {}
 
-      attribute_names(options).each do |attribute_name|
-        hash[attribute_name] = read_attribute_for_hashing(attribute_name, options)
+      _attribute_names(options).each do |attribute_name|
+        hash[attribute_name] = _read_attribute_for_hashing(attribute_name, options)
       end
 
       method_names(options).each do |method_name|
@@ -36,9 +36,9 @@ module SmoothOperator
 
 
     protected ##################### PROTECTED ###################
-    
+
     # TODO: COMPLEX METHOD
-    def attribute_names(options)
+    def _attribute_names(options)
       attribute_names = internal_data.keys.sort
 
       if only = options[:only]
@@ -54,19 +54,19 @@ module SmoothOperator
       [*options[:methods]].select { |n| respond_to?(n) }
     end
 
-    def read_attribute_for_hashing(attribute_name, options)
+    def _read_attribute_for_hashing(attribute_name, options)
       object = read_attribute_for_serialization(attribute_name)
 
       _options = options[attribute_name] || options[attribute_name.to_sym]
 
       if object.is_a?(Array)
-        object.map { |array_entry| attribute_to_hash(array_entry, _options) }
+        object.map { |array_entry| _attribute_to_hash(array_entry, _options) }
       else
-        attribute_to_hash(object, _options)
+        _attribute_to_hash(object, _options)
       end
     end
 
-    def attribute_to_hash(object, options = nil)
+    def _attribute_to_hash(object, options = nil)
       if object.respond_to?(:serializable_hash)
         Helpers.symbolyze_keys(object.serializable_hash(options))
       else

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