duck_record 0.0.9.1 → 0.0.10

data/lib/duck_record/validations/uniqueness_on_real_record.rb

@@ -12,9 +12,9 @@ module DuckRecord
         end
 
         @finder_class = if options[:class_name].present?
-                          @finder_class = options[:class_name].safe_constantize
+                          options[:class_name].safe_constantize
                         elsif options[:class].present? && options[:class].is_a?(Class)
-                          @finder_class = options[:class]
+                          options[:class]
                         else
                           nil
                         end
@@ -59,58 +59,58 @@ module DuckRecord
 
       protected
 
-      def build_relation(klass, table, attribute, value) #:nodoc:
-        if reflection = klass._reflect_on_association(attribute)
-          attribute = reflection.foreign_key
-          value = value.attributes[reflection.klass.primary_key] unless value.nil?
-        end
-
-        # the attribute may be an aliased attribute
-        if klass.attribute_alias?(attribute)
-          attribute = klass.attribute_alias(attribute)
-        end
+        def build_relation(klass, table, attribute, value) #:nodoc:
+          if reflection = klass._reflect_on_association(attribute)
+            attribute = reflection.foreign_key
+            value = value.attributes[reflection.klass.primary_key] unless value.nil?
+          end
 
-        attribute_name = attribute.to_s
+          # the attribute may be an aliased attribute
+          if klass.attribute_alias?(attribute)
+            attribute = klass.attribute_alias(attribute)
+          end
 
-        column = klass.columns_hash[attribute_name]
-        cast_type = klass.type_for_attribute(attribute_name)
-        value = cast_type.serialize(value)
-        value = klass.connection.type_cast(value)
+          attribute_name = attribute.to_s
 
-        comparison = if !options[:case_sensitive] && !value.nil?
-          # will use SQL LOWER function before comparison, unless it detects a case insensitive collation
-          klass.connection.case_insensitive_comparison(table, attribute, column, value)
-        else
-          klass.connection.case_sensitive_comparison(table, attribute, column, value)
-        end
-        if value.nil?
-          klass.unscoped.where(comparison)
-        else
-          bind = ActiveRecord::Relation::QueryAttribute.new(attribute_name, value, ActiveRecord::Type::Value.new)
-          klass.unscoped.where(comparison, bind)
-        end
-      rescue RangeError
-        klass.none
-      end
+          column = klass.columns_hash[attribute_name]
+          cast_type = klass.type_for_attribute(attribute_name)
+          value = cast_type.serialize(value)
+          value = klass.connection.type_cast(value)
 
-      def scope_relation(record, table, relation)
-        Array(options[:scope]).each do |scope_item|
-          scope_value = if record.class._reflect_on_association(scope_item)
-            record.association(scope_item).reader
+          comparison = if !options[:case_sensitive] && !value.nil?
+            # will use SQL LOWER function before comparison, unless it detects a case insensitive collation
+            klass.connection.case_insensitive_comparison(table, attribute, column, value)
           else
-            record._read_attribute(scope_item)
+            klass.connection.case_sensitive_comparison(table, attribute, column, value)
           end
-          relation = relation.where(scope_item => scope_value)
+          if value.nil?
+            klass.unscoped.where(comparison)
+          else
+            bind = ActiveRecord::Relation::QueryAttribute.new(attribute_name, value, ActiveRecord::Type::Value.new)
+            klass.unscoped.where(comparison, bind)
+          end
+        rescue RangeError
+          klass.none
         end
 
-        relation
-      end
+        def scope_relation(record, table, relation)
+          Array(options[:scope]).each do |scope_item|
+            scope_value = if record.class._reflect_on_association(scope_item)
+              record.association(scope_item).reader
+            else
+              record._read_attribute(scope_item)
+            end
+            relation = relation.where(scope_item => scope_value)
+          end
 
-      def map_enum_attribute(klass, attribute, value)
-        mapping = klass.defined_enums[attribute.to_s]
-        value = mapping[value] if value && mapping
-        value
-      end
+          relation
+        end
+
+        def map_enum_attribute(klass, attribute, value)
+          mapping = klass.defined_enums[attribute.to_s]
+          value = mapping[value] if value && mapping
+          value
+        end
     end
 
     module ClassMethods

data/lib/duck_record/validations.rb

@@ -31,12 +31,12 @@ module DuckRecord
 
     private
 
-    def default_validation_context
-      :default
-    end
+      def default_validation_context
+        :default
+      end
 
-    def perform_validations(options = {})
-      options[:validate] == false || valid?(options[:context])
-    end
+      def perform_validations(options = {})
+        options[:validate] == false || valid?(options[:context])
+      end
   end
 end

data/lib/duck_record/version.rb

@@ -1,3 +1,3 @@
 module DuckRecord
-  VERSION = '0.0.9.1'
+  VERSION = "0.0.10"
 end

data/lib/duck_record.rb

@@ -1,9 +1,9 @@
-require 'active_support'
-require 'active_support/rails'
-require 'active_model'
+require "active_support"
+require "active_support/rails"
+require "active_model"
 
-require 'duck_record/type'
-require 'duck_record/attribute_set'
+require "duck_record/type"
+require "duck_record/attribute_set"
 
 module DuckRecord
   extend ActiveSupport::Autoload
@@ -22,7 +22,7 @@ module DuckRecord
   autoload :Validations
 
   eager_autoload do
-    autoload :DuckRecordError, 'duck_record/errors'
+    autoload :DuckRecordError, "duck_record/errors"
 
     autoload :Associations
     autoload :AttributeAssignment
@@ -50,5 +50,5 @@ module DuckRecord
 end
 
 ActiveSupport.on_load(:i18n) do
-  I18n.load_path << File.dirname(__FILE__) + '/duck_record/locale/en.yml'
+  I18n.load_path << File.dirname(__FILE__) + "/duck_record/locale/en.yml"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: duck_record
 version: !ruby/object:Gem::Version
-  version: 0.0.9.1
+  version: 0.0.10
 platform: ruby
 authors:
 - jasl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-20 00:00:00.000000000 Z
+date: 2017-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -66,10 +66,11 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: "It looks like Active Record and quacks like Active Record, but it can't
-  do persistence or querying,\n    it's Duck Record! \n    Actually it's extract from
-  Active Record.\n    Used for creating virtual models like ActiveType or ModelAttribute
-  does."
+description: |-
+  It looks like Active Record and quacks like Active Record, but it can't do persistence or querying,
+      it's Duck Record!
+      Actually it's extract from Active Record.
+      Used for creating virtual models like ActiveType or ModelAttribute does.
 email:
 - jasl9187@hotmail.com
 executables: []