duck_record 0.0.9.1 → 0.0.10

data/lib/duck_record/attribute_methods/read.rb

@@ -6,42 +6,42 @@ module DuckRecord
       module ClassMethods
         private
 
-        # We want to generate the methods via module_eval rather than
-        # define_method, because define_method is slower on dispatch.
-        # Evaluating many similar methods may use more memory as the instruction
-        # sequences are duplicated and cached (in MRI).  define_method may
-        # be slower on dispatch, but if you're careful about the closure
-        # created, then define_method will consume much less memory.
-        #
-        # But sometimes the database might return columns with
-        # characters that are not allowed in normal method names (like
-        # 'my_column(omg)'. So to work around this we first define with
-        # the __temp__ identifier, and then use alias method to rename
-        # it to what we want.
-        #
-        # We are also defining a constant to hold the frozen string of
-        # the attribute name. Using a constant means that we do not have
-        # to allocate an object on each call to the attribute method.
-        # Making it frozen means that it doesn't get duped when used to
-        # key the @attributes in read_attribute.
-        def define_method_attribute(name)
-          safe_name = name.unpack('h*'.freeze).first
-          temp_method = "__temp__#{safe_name}"
+          # We want to generate the methods via module_eval rather than
+          # define_method, because define_method is slower on dispatch.
+          # Evaluating many similar methods may use more memory as the instruction
+          # sequences are duplicated and cached (in MRI).  define_method may
+          # be slower on dispatch, but if you're careful about the closure
+          # created, then define_method will consume much less memory.
+          #
+          # But sometimes the database might return columns with
+          # characters that are not allowed in normal method names (like
+          # 'my_column(omg)'. So to work around this we first define with
+          # the __temp__ identifier, and then use alias method to rename
+          # it to what we want.
+          #
+          # We are also defining a constant to hold the frozen string of
+          # the attribute name. Using a constant means that we do not have
+          # to allocate an object on each call to the attribute method.
+          # Making it frozen means that it doesn't get duped when used to
+          # key the @attributes in read_attribute.
+          def define_method_attribute(name)
+            safe_name = name.unpack("h*".freeze).first
+            temp_method = "__temp__#{safe_name}"
 
-          DuckRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
+            DuckRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
 
-          generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
             def #{temp_method}
               name = ::DuckRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
               _read_attribute(name) { |n| missing_attribute(n, caller) }
             end
           STR
 
-          generated_attribute_methods.module_eval do
-            alias_method name, temp_method
-            undef_method temp_method
+            generated_attribute_methods.module_eval do
+              alias_method name, temp_method
+              undef_method temp_method
+            end
           end
-        end
       end
 
       # Returns the value of the attribute identified by <tt>attr_name</tt> after

data/lib/duck_record/attribute_methods/write.rb

@@ -4,17 +4,17 @@ module DuckRecord
       extend ActiveSupport::Concern
 
       included do
-        attribute_method_suffix '='
+        attribute_method_suffix "="
       end
 
       module ClassMethods
         private
 
-        def define_method_attribute=(name)
-          safe_name = name.unpack("h*".freeze).first
-          DuckRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
+          def define_method_attribute=(name)
+            safe_name = name.unpack("h*".freeze).first
+            DuckRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
 
-          generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
             def __temp__#{safe_name}=(value, force_write_readonly: false)
               name = ::DuckRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
               write_attribute(name, value, force_write_readonly: force_write_readonly)
@@ -22,7 +22,7 @@ module DuckRecord
             alias_method #{(name + '=').inspect}, :__temp__#{safe_name}=
             undef_method :__temp__#{safe_name}=
           STR
-        end
+          end
       end
 
       # Updates the attribute identified by <tt>attr_name</tt> with the
@@ -44,24 +44,24 @@ module DuckRecord
 
       private
 
-      # Handle *= for method_missing.
-      def attribute=(attribute_name, value, force_write_readonly: false)
-        write_attribute(attribute_name, value, force_write_readonly: force_write_readonly)
-      end
+        # Handle *= for method_missing.
+        def attribute=(attribute_name, value, force_write_readonly: false)
+          write_attribute(attribute_name, value, force_write_readonly: force_write_readonly)
+        end
 
-      def write_attribute_with_type_cast(attr_name, value, should_type_cast, force_write_readonly: false)
-        attr_name = attr_name.to_s
+        def write_attribute_with_type_cast(attr_name, value, should_type_cast, force_write_readonly: false)
+          attr_name = attr_name.to_s
 
-        return if !force_write_readonly && self.class.readonly_attributes.include?(attr_name)
+          return if !force_write_readonly && self.class.readonly_attributes.include?(attr_name)
 
-        if should_type_cast
-          @attributes.write_from_user(attr_name, value)
-        else
-          @attributes.write_cast_value(attr_name, value)
-        end
+          if should_type_cast
+            @attributes.write_from_user(attr_name, value)
+          else
+            @attributes.write_cast_value(attr_name, value)
+          end
 
-        value
-      end
+          value
+        end
     end
   end
 end

data/lib/duck_record/attribute_methods.rb

@@ -1,7 +1,7 @@
-require 'active_support/core_ext/enumerable'
-require 'active_support/core_ext/string/filters'
-require 'mutex_m'
-require 'concurrent/map'
+require "active_support/core_ext/enumerable"
+require "active_support/core_ext/string/filters"
+require "mutex_m"
+require "concurrent/map"
 
 module DuckRecord
   # = Active Record Attribute Methods
@@ -317,9 +317,9 @@ module DuckRecord
 
     protected
 
-    def attribute_method?(attr_name) # :nodoc:
-      # We check defined? because Syck calls respond_to? before actually calling initialize.
-      defined?(@attributes) && @attributes.key?(attr_name)
-    end
+      def attribute_method?(attr_name) # :nodoc:
+        # We check defined? because Syck calls respond_to? before actually calling initialize.
+        defined?(@attributes) && @attributes.key?(attr_name)
+      end
   end
 end

data/lib/duck_record/attribute_mutation_tracker.rb

@@ -64,13 +64,13 @@ module DuckRecord
     # Workaround for Ruby 2.2 "private attribute?" warning.
     protected
 
-    attr_reader :attributes, :forced_changes
+      attr_reader :attributes, :forced_changes
 
     private
 
-    def attr_names
-      attributes.keys
-    end
+      def attr_names
+        attributes.keys
+      end
   end
 
   class NullMutationTracker # :nodoc:

data/lib/duck_record/attribute_set/yaml_encoder.rb

@@ -8,7 +8,7 @@ module DuckRecord
       end
 
       def encode(attribute_set, coder)
-        coder['concise_attributes'] = attribute_set.each_value.map do |attr|
+        coder["concise_attributes"] = attribute_set.each_value.map do |attr|
           if attr.type.equal?(default_types[attr.name])
             attr.with_type(nil)
           else
@@ -18,10 +18,10 @@ module DuckRecord
       end
 
       def decode(coder)
-        if coder['attributes']
-          coder['attributes']
+        if coder["attributes"]
+          coder["attributes"]
         else
-          attributes_hash = Hash[coder['concise_attributes'].map do |attr|
+          attributes_hash = Hash[coder["concise_attributes"].map do |attr|
             if attr.type.nil?
               attr = attr.with_type(default_types[attr.name])
             end
@@ -35,7 +35,7 @@ module DuckRecord
       # Workaround for Ruby 2.2 'private attribute?' warning.
       protected
 
-      attr_reader :default_types
+        attr_reader :default_types
     end
   end
 end

data/lib/duck_record/attribute_set.rb

@@ -1,4 +1,4 @@
-require 'duck_record/attribute_set/yaml_encoder'
+require "duck_record/attribute_set/yaml_encoder"
 
 module DuckRecord
   class AttributeSet # :nodoc:
@@ -87,12 +87,12 @@ module DuckRecord
     # Workaround for Ruby 2.2 "private attribute?" warning.
     protected
 
-    attr_reader :attributes
+      attr_reader :attributes
 
     private
 
-    def initialized_attributes
-      attributes.select { |_, attr| attr.initialized? }
-    end
+      def initialized_attributes
+        attributes.select { |_, attr| attr.initialized? }
+      end
   end
 end

data/lib/duck_record/attributes.rb

@@ -240,22 +240,22 @@ module DuckRecord
 
       private
 
-      NO_DEFAULT_PROVIDED = Object.new # :nodoc:
-      private_constant :NO_DEFAULT_PROVIDED
+        NO_DEFAULT_PROVIDED = Object.new # :nodoc:
+        private_constant :NO_DEFAULT_PROVIDED
 
-      def define_default_attribute(name, value, type)
-        if value == NO_DEFAULT_PROVIDED
-          default_attribute = _default_attributes[name].with_type(type)
-        else
-          default_attribute = Attribute::UserProvidedDefault.new(
-            name,
-            value,
-            type,
-            _default_attributes.fetch(name.to_s) { nil },
-          )
+        def define_default_attribute(name, value, type)
+          if value == NO_DEFAULT_PROVIDED
+            default_attribute = _default_attributes[name].with_type(type)
+          else
+            default_attribute = Attribute::UserProvidedDefault.new(
+              name,
+              value,
+              type,
+              _default_attributes.fetch(name.to_s) { nil },
+            )
+          end
+          _default_attributes[name] = default_attribute
         end
-        _default_attributes[name] = default_attribute
-      end
     end
   end
 end

data/lib/duck_record/base.rb

@@ -1,21 +1,21 @@
-require 'yaml'
-require 'active_support/benchmarkable'
-require 'active_support/dependencies'
-require 'active_support/descendants_tracker'
-require 'active_support/time'
-require 'active_support/core_ext/module/attribute_accessors'
-require 'active_support/core_ext/array/extract_options'
-require 'active_support/core_ext/hash/deep_merge'
-require 'active_support/core_ext/hash/slice'
-require 'active_support/core_ext/hash/transform_values'
-require 'active_support/core_ext/string/behavior'
-require 'active_support/core_ext/kernel/singleton_class'
-require 'active_support/core_ext/module/introspection'
-require 'active_support/core_ext/object/duplicable'
-require 'active_support/core_ext/class/subclasses'
-require 'duck_record/define_callbacks'
-require 'duck_record/errors'
-require 'duck_record/attributes'
+require "yaml"
+require "active_support/benchmarkable"
+require "active_support/dependencies"
+require "active_support/descendants_tracker"
+require "active_support/time"
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/hash/deep_merge"
+require "active_support/core_ext/hash/slice"
+require "active_support/core_ext/hash/transform_values"
+require "active_support/core_ext/string/behavior"
+require "active_support/core_ext/kernel/singleton_class"
+require "active_support/core_ext/module/introspection"
+require "active_support/core_ext/object/duplicable"
+require "active_support/core_ext/class/subclasses"
+require "duck_record/define_callbacks"
+require "duck_record/errors"
+require "duck_record/attributes"
 
 module DuckRecord #:nodoc:
   # = Active Record

data/lib/duck_record/callbacks.rb

@@ -318,7 +318,7 @@ module DuckRecord
     included do
       include ActiveModel::Validations::Callbacks
 
-      define_model_callbacks :initialize, :only => :after
+      define_model_callbacks :initialize, only: :after
     end
   end
 end

data/lib/duck_record/core.rb

@@ -1,7 +1,7 @@
-require 'thread'
-require 'active_support/core_ext/hash/indifferent_access'
-require 'active_support/core_ext/object/duplicable'
-require 'active_support/core_ext/string/filters'
+require "thread"
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/object/duplicable"
+require "active_support/core_ext/string/filters"
 
 module DuckRecord
   module Core
@@ -151,7 +151,7 @@ module DuckRecord
     #   coder # => {"attributes" => {"id" => nil, ... }}
     def encode_with(coder)
       self.class.yaml_encoder.encode(@attributes, coder)
-      coder['duck_record_yaml_version'] = 2
+      coder["duck_record_yaml_version"] = 2
     end
 
     # Clone and freeze the attributes hash such that associations are still
@@ -187,9 +187,9 @@ module DuckRecord
           if has_attribute?(name)
             "#{name}: #{attribute_for_inspect(name)}"
           end
-        end.compact.join(', ')
+        end.compact.join(", ")
       else
-        'not initialized'
+        "not initialized"
       end
 
       "#<#{self.class} #{inspection}>"
@@ -201,19 +201,19 @@ module DuckRecord
       return super if custom_inspect_method_defined?
       pp.object_address_group(self) do
         if defined?(@attributes) && @attributes
-          pp.seplist(self.class.attribute_names, proc { pp.text ',' }) do |attribute_name|
+          pp.seplist(self.class.attribute_names, proc { pp.text "," }) do |attribute_name|
             attribute_value = read_attribute(attribute_name)
-            pp.breakable ' '
+            pp.breakable " "
             pp.group(1) do
               pp.text attribute_name
-              pp.text ':'
+              pp.text ":"
               pp.breakable
               pp.pp attribute_value
             end
           end
         else
-          pp.breakable ' '
-          pp.text 'not initialized'
+          pp.breakable " "
+          pp.text "not initialized"
         end
       end
     end
@@ -225,33 +225,33 @@ module DuckRecord
 
     private
 
-    # +Array#flatten+ will call +#to_ary+ (recursively) on each of the elements of
-    # the array, and then rescues from the possible +NoMethodError+. If those elements are
-    # +DuckRecord::Base+'s, then this triggers the various +method_missing+'s that we have,
-    # which significantly impacts upon performance.
-    #
-    # So we can avoid the +method_missing+ hit by explicitly defining +#to_ary+ as +nil+ here.
-    #
-    # See also http://tenderlovemaking.com/2011/06/28/til-its-ok-to-return-nil-from-to_ary.html
-    def to_ary
-      nil
-    end
+      # +Array#flatten+ will call +#to_ary+ (recursively) on each of the elements of
+      # the array, and then rescues from the possible +NoMethodError+. If those elements are
+      # +DuckRecord::Base+'s, then this triggers the various +method_missing+'s that we have,
+      # which significantly impacts upon performance.
+      #
+      # So we can avoid the +method_missing+ hit by explicitly defining +#to_ary+ as +nil+ here.
+      #
+      # See also http://tenderlovemaking.com/2011/06/28/til-its-ok-to-return-nil-from-to_ary.html
+      def to_ary
+        nil
+      end
 
-    def init_internals
-      @readonly = false
-    end
+      def init_internals
+        @readonly = false
+      end
 
-    def initialize_internals_callback
-    end
+      def initialize_internals_callback
+      end
 
-    def thaw
-      if frozen?
-        @attributes = @attributes.dup
+      def thaw
+        if frozen?
+          @attributes = @attributes.dup
+        end
       end
-    end
 
-    def custom_inspect_method_defined?
-      self.class.instance_method(:inspect).owner != DuckRecord::Base.instance_method(:inspect).owner
-    end
+      def custom_inspect_method_defined?
+        self.class.instance_method(:inspect).owner != DuckRecord::Base.instance_method(:inspect).owner
+      end
   end
 end

data/lib/duck_record/inheritance.rb

@@ -1,4 +1,4 @@
-require 'active_support/core_ext/hash/indifferent_access'
+require "active_support/core_ext/hash/indifferent_access"
 
 module DuckRecord
   # == Single table inheritance
@@ -96,35 +96,35 @@ module DuckRecord
 
       protected
 
-      # Returns the class type of the record using the current module as a prefix. So descendants of
-      # MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
-      def compute_type(type_name)
-        if type_name.start_with?('::'.freeze)
-          # If the type is prefixed with a scope operator then we assume that
-          # the type_name is an absolute reference.
-          ActiveSupport::Dependencies.constantize(type_name)
-        else
-          type_candidate = @_type_candidates_cache[type_name]
-          if type_candidate && type_constant = ActiveSupport::Dependencies.safe_constantize(type_candidate)
-            return type_constant
-          end
+        # Returns the class type of the record using the current module as a prefix. So descendants of
+        # MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
+        def compute_type(type_name)
+          if type_name.start_with?("::".freeze)
+            # If the type is prefixed with a scope operator then we assume that
+            # the type_name is an absolute reference.
+            ActiveSupport::Dependencies.constantize(type_name)
+          else
+            type_candidate = @_type_candidates_cache[type_name]
+            if type_candidate && type_constant = ActiveSupport::Dependencies.safe_constantize(type_candidate)
+              return type_constant
+            end
 
-          # Build a list of candidates to search for
-          candidates = []
-          name.scan(/::|$/) { candidates.unshift "#{$`}::#{type_name}" }
-          candidates << type_name
+            # Build a list of candidates to search for
+            candidates = []
+            name.scan(/::|$/) { candidates.unshift "#{$`}::#{type_name}" }
+            candidates << type_name
 
-          candidates.each do |candidate|
-            constant = ActiveSupport::Dependencies.safe_constantize(candidate)
-            if candidate == constant.to_s
-              @_type_candidates_cache[type_name] = candidate
-              return constant
+            candidates.each do |candidate|
+              constant = ActiveSupport::Dependencies.safe_constantize(candidate)
+              if candidate == constant.to_s
+                @_type_candidates_cache[type_name] = candidate
+                return constant
+              end
             end
-          end
 
-          raise NameError.new("uninitialized constant #{candidates.first}", candidates.first)
+            raise NameError.new("uninitialized constant #{candidates.first}", candidates.first)
+          end
         end
-      end
     end
   end
 end

data/lib/duck_record/model_schema.rb

@@ -7,7 +7,6 @@ module DuckRecord
     end
 
     module ClassMethods
-
       def attribute_types # :nodoc:
         load_schema
         @attribute_types ||= Hash.new
@@ -42,19 +41,19 @@ module DuckRecord
 
       private
 
-      def schema_loaded?
-        defined?(@loaded) && @loaded
-      end
+        def schema_loaded?
+          defined?(@loaded) && @loaded
+        end
 
-      def load_schema
-        unless schema_loaded?
-          load_schema!
+        def load_schema
+          unless schema_loaded?
+            load_schema!
+          end
         end
-      end
 
-      def load_schema!
-        @loaded = true
-      end
+        def load_schema!
+          @loaded = true
+        end
     end
   end
 end