duck_record 0.0.1

data/lib/duck_record/attribute_methods/before_type_cast.rb

@@ -0,0 +1,76 @@
+module DuckRecord
+  module AttributeMethods
+    # = Active Record Attribute Methods Before Type Cast
+    #
+    # DuckRecord::AttributeMethods::BeforeTypeCast provides a way to
+    # read the value of the attributes before typecasting and deserialization.
+    #
+    #   class Task < DuckRecord::Base
+    #   end
+    #
+    #   task = Task.new(id: '1', completed_on: '2012-10-21')
+    #   task.id           # => 1
+    #   task.completed_on # => Sun, 21 Oct 2012
+    #
+    #   task.attributes_before_type_cast
+    #   # => {"id"=>"1", "completed_on"=>"2012-10-21", ... }
+    #   task.read_attribute_before_type_cast('id')           # => "1"
+    #   task.read_attribute_before_type_cast('completed_on') # => "2012-10-21"
+    #
+    # In addition to #read_attribute_before_type_cast and #attributes_before_type_cast,
+    # it declares a method for all attributes with the <tt>*_before_type_cast</tt>
+    # suffix.
+    #
+    #   task.id_before_type_cast           # => "1"
+    #   task.completed_on_before_type_cast # => "2012-10-21"
+    module BeforeTypeCast
+      extend ActiveSupport::Concern
+
+      included do
+        attribute_method_suffix '_before_type_cast'
+        attribute_method_suffix '_came_from_user?'
+      end
+
+      # Returns the value of the attribute identified by +attr_name+ before
+      # typecasting and deserialization.
+      #
+      #   class Task < DuckRecord::Base
+      #   end
+      #
+      #   task = Task.new(id: '1', completed_on: '2012-10-21')
+      #   task.read_attribute('id')                            # => 1
+      #   task.read_attribute_before_type_cast('id')           # => '1'
+      #   task.read_attribute('completed_on')                  # => Sun, 21 Oct 2012
+      #   task.read_attribute_before_type_cast('completed_on') # => "2012-10-21"
+      #   task.read_attribute_before_type_cast(:completed_on)  # => "2012-10-21"
+      def read_attribute_before_type_cast(attr_name)
+        @attributes[attr_name.to_s].value_before_type_cast
+      end
+
+      # Returns a hash of attributes before typecasting and deserialization.
+      #
+      #   class Task < DuckRecord::Base
+      #   end
+      #
+      #   task = Task.new(title: nil, is_done: true, completed_on: '2012-10-21')
+      #   task.attributes
+      #   # => {"id"=>nil, "title"=>nil, "is_done"=>true, "completed_on"=>Sun, 21 Oct 2012, "created_at"=>nil, "updated_at"=>nil}
+      #   task.attributes_before_type_cast
+      #   # => {"id"=>nil, "title"=>nil, "is_done"=>true, "completed_on"=>"2012-10-21", "created_at"=>nil, "updated_at"=>nil}
+      def attributes_before_type_cast
+        @attributes.values_before_type_cast
+      end
+
+      private
+
+        # Handle *_before_type_cast for method_missing.
+        def attribute_before_type_cast(attribute_name)
+          read_attribute_before_type_cast(attribute_name)
+        end
+
+        def attribute_came_from_user?(attribute_name)
+          @attributes[attribute_name].came_from_user?
+        end
+    end
+  end
+end

data/lib/duck_record/attribute_methods/dirty.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+require 'active_support/core_ext/module/attribute_accessors'
+require 'duck_record/attribute_mutation_tracker'
+
+module DuckRecord
+  module AttributeMethods
+    module Dirty # :nodoc:
+      extend ActiveSupport::Concern
+
+      include ActiveModel::Dirty
+
+      included do
+        class_attribute :partial_writes, instance_writer: false
+        self.partial_writes = true
+      end
+
+      def initialize_dup(other) # :nodoc:
+        super
+        @attributes = self.class._default_attributes.map do |attr|
+          attr.with_value_from_user(@attributes.fetch_value(attr.name))
+        end
+        @mutation_tracker = nil
+      end
+
+      def changes_applied
+        @previous_mutation_tracker = mutation_tracker
+        @changed_attributes = HashWithIndifferentAccess.new
+        store_original_attributes
+      end
+
+      def clear_changes_information
+        @previous_mutation_tracker = nil
+        @changed_attributes = HashWithIndifferentAccess.new
+        store_original_attributes
+      end
+
+      def raw_write_attribute(attr_name, *)
+        result = super
+        clear_attribute_change(attr_name)
+        result
+      end
+
+      def clear_attribute_changes(attr_names)
+        super
+        attr_names.each do |attr_name|
+          clear_attribute_change(attr_name)
+        end
+      end
+
+      def changed_attributes
+        # This should only be set by methods which will call changed_attributes
+        # multiple times when it is known that the computed value cannot change.
+        if defined?(@cached_changed_attributes)
+          @cached_changed_attributes
+        else
+          super.reverse_merge(mutation_tracker.changed_values).freeze
+        end
+      end
+
+      def changes
+        cache_changed_attributes do
+          super
+        end
+      end
+
+      def previous_changes
+        previous_mutation_tracker.changes
+      end
+
+      def attribute_changed_in_place?(attr_name)
+        mutation_tracker.changed_in_place?(attr_name)
+      end
+
+      private
+
+      def mutation_tracker
+        unless defined?(@mutation_tracker)
+          @mutation_tracker = nil
+        end
+        @mutation_tracker ||= AttributeMutationTracker.new(@attributes)
+      end
+
+      def changes_include?(attr_name)
+        super || mutation_tracker.changed?(attr_name)
+      end
+
+      def clear_attribute_change(attr_name)
+        mutation_tracker.forget_change(attr_name)
+      end
+
+      def _update_record(*)
+        partial_writes? ? super(keys_for_partial_write) : super
+      end
+
+      def _create_record(*)
+        partial_writes? ? super(keys_for_partial_write) : super
+      end
+
+      def keys_for_partial_write
+        changed & self.class.column_names
+      end
+
+      def store_original_attributes
+        @attributes = @attributes.map(&:forgetting_assignment)
+        @mutation_tracker = nil
+      end
+
+      def previous_mutation_tracker
+        @previous_mutation_tracker ||= NullMutationTracker.instance
+      end
+
+      def cache_changed_attributes
+        @cached_changed_attributes = changed_attributes
+        yield
+      ensure
+        clear_changed_attributes_cache
+      end
+
+      def clear_changed_attributes_cache
+        remove_instance_variable(:@cached_changed_attributes) if defined?(@cached_changed_attributes)
+      end
+    end
+  end
+end

data/lib/duck_record/attribute_methods/read.rb

@@ -0,0 +1,78 @@
+module DuckRecord
+  module AttributeMethods
+    module Read
+      extend ActiveSupport::Concern
+
+      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}"
+
+          DuckRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
+
+          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
+          end
+        end
+      end
+
+      # Returns the value of the attribute identified by <tt>attr_name</tt> after
+      # it has been typecast (for example, "2004-12-12" in a date column is cast
+      # to a date object, like Date.new(2004, 12, 12)).
+      def read_attribute(attr_name, &block)
+        name = if self.class.attribute_alias?(attr_name)
+          self.class.attribute_alias(attr_name).to_s
+        else
+          attr_name.to_s
+        end
+
+        _read_attribute(name, &block)
+      end
+
+      # This method exists to avoid the expensive primary_key check internally, without
+      # breaking compatibility with the read_attribute API
+      if defined?(JRUBY_VERSION)
+        # This form is significantly faster on JRuby, and this is one of our biggest hotspots.
+        # https://github.com/jruby/jruby/pull/2562
+        def _read_attribute(attr_name, &block) # :nodoc
+          @attributes.fetch_value(attr_name.to_s, &block)
+        end
+      else
+        def _read_attribute(attr_name) # :nodoc:
+          @attributes.fetch_value(attr_name.to_s) { |n| yield n if block_given? }
+        end
+      end
+
+      alias :attribute :_read_attribute
+      private :attribute
+    end
+  end
+end

data/lib/duck_record/attribute_methods/write.rb

@@ -0,0 +1,65 @@
+module DuckRecord
+  module AttributeMethods
+    module Write
+      extend ActiveSupport::Concern
+
+      included do
+        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
+
+          generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
+            def __temp__#{safe_name}=(value)
+              name = ::DuckRecord::AttributeMethods::AttrNames::ATTR_#{safe_name}
+              write_attribute(name, value)
+            end
+            alias_method #{(name + '=').inspect}, :__temp__#{safe_name}=
+            undef_method :__temp__#{safe_name}=
+          STR
+        end
+      end
+
+      # Updates the attribute identified by <tt>attr_name</tt> with the
+      # specified +value+. Empty strings for Integer and Float columns are
+      # turned into +nil+.
+      def write_attribute(attr_name, value)
+        name = if self.class.attribute_alias?(attr_name)
+          self.class.attribute_alias(attr_name).to_s
+        else
+          attr_name.to_s
+        end
+
+        write_attribute_with_type_cast(name, value, true)
+      end
+
+      def raw_write_attribute(attr_name, value) # :nodoc:
+        write_attribute_with_type_cast(attr_name, value, false)
+      end
+
+      private
+
+      # Handle *= for method_missing.
+      def attribute=(attribute_name, value)
+        write_attribute(attribute_name, value)
+      end
+
+      def write_attribute_with_type_cast(attr_name, value, should_type_cast)
+        attr_name = attr_name.to_s
+
+        if should_type_cast
+          @attributes.write_from_user(attr_name, value)
+        else
+          @attributes.write_cast_value(attr_name, value)
+        end
+
+        value
+      end
+    end
+  end
+end

data/lib/duck_record/attribute_methods.rb

@@ -0,0 +1,332 @@
+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
+  module AttributeMethods
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+
+    included do
+      initialize_generated_modules
+
+      include Read
+      include Write
+      include BeforeTypeCast
+      include Dirty
+      include Serialization
+    end
+
+    AttrNames = Module.new {
+      def self.set_name_cache(name, value)
+        const_name = "ATTR_#{name}"
+        unless const_defined? const_name
+          const_set const_name, value.dup.freeze
+        end
+      end
+    }
+
+    BLACKLISTED_CLASS_METHODS = %w(private public protected allocate new name parent superclass)
+
+    class GeneratedAttributeMethods < Module; end # :nodoc:
+
+    module ClassMethods
+      def inherited(child_class) #:nodoc:
+        child_class.initialize_generated_modules
+        super
+      end
+
+      def initialize_generated_modules # :nodoc:
+        @generated_attribute_methods = GeneratedAttributeMethods.new { extend Mutex_m }
+        @attribute_methods_generated = false
+        include @generated_attribute_methods
+
+        super
+      end
+
+      # Generates all the attribute related methods for columns in the database
+      # accessors, mutators and query methods.
+      def define_attribute_methods # :nodoc:
+        return false if @attribute_methods_generated
+        # Use a mutex; we don't want two threads simultaneously trying to define
+        # attribute methods.
+        generated_attribute_methods.synchronize do
+          return false if @attribute_methods_generated
+          superclass.define_attribute_methods unless self == base_class
+          super(attribute_names)
+          @attribute_methods_generated = true
+        end
+        true
+      end
+
+      def undefine_attribute_methods # :nodoc:
+        generated_attribute_methods.synchronize do
+          super if defined?(@attribute_methods_generated) && @attribute_methods_generated
+          @attribute_methods_generated = false
+        end
+      end
+
+      # Raises an DuckRecord::DangerousAttributeError exception when an
+      # \Active \Record method is defined in the model, otherwise +false+.
+      #
+      #   class Person < DuckRecord::Base
+      #     def save
+      #       'already defined by Active Record'
+      #     end
+      #   end
+      #
+      #   Person.instance_method_already_implemented?(:save)
+      #   # => DuckRecord::DangerousAttributeError: save is defined by Active Record. Check to make sure that you don't have an attribute or method with the same name.
+      #
+      #   Person.instance_method_already_implemented?(:name)
+      #   # => false
+      def instance_method_already_implemented?(method_name)
+        if dangerous_attribute_method?(method_name)
+          raise DangerousAttributeError, "#{method_name} is defined by Active Record. Check to make sure that you don't have an attribute or method with the same name."
+        end
+
+        if superclass == Base
+          super
+        else
+          # If ThisClass < ... < SomeSuperClass < ... < Base and SomeSuperClass
+          # defines its own attribute method, then we don't want to overwrite that.
+          defined = method_defined_within?(method_name, superclass, Base) &&
+            ! superclass.instance_method(method_name).owner.is_a?(GeneratedAttributeMethods)
+          defined || super
+        end
+      end
+
+      # A method name is 'dangerous' if it is already (re)defined by Active Record, but
+      # not by any ancestors. (So 'puts' is not dangerous but 'save' is.)
+      def dangerous_attribute_method?(name) # :nodoc:
+        method_defined_within?(name, Base)
+      end
+
+      def method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc:
+        if klass.method_defined?(name) || klass.private_method_defined?(name)
+          if superklass.method_defined?(name) || superklass.private_method_defined?(name)
+            klass.instance_method(name).owner != superklass.instance_method(name).owner
+          else
+            true
+          end
+        else
+          false
+        end
+      end
+
+      # A class method is 'dangerous' if it is already (re)defined by Active Record, but
+      # not by any ancestors. (So 'puts' is not dangerous but 'new' is.)
+      def dangerous_class_method?(method_name)
+        BLACKLISTED_CLASS_METHODS.include?(method_name.to_s) || class_method_defined_within?(method_name, Base)
+      end
+
+      def class_method_defined_within?(name, klass, superklass = klass.superclass) # :nodoc:
+        if klass.respond_to?(name, true)
+          if superklass.respond_to?(name, true)
+            klass.method(name).owner != superklass.method(name).owner
+          else
+            true
+          end
+        else
+          false
+        end
+      end
+
+      # Returns an array of column names as strings if it's not an abstract class and
+      # table exists. Otherwise it returns an empty array.
+      #
+      #   class Person < DuckRecord::Base
+      #   end
+      #
+      #   Person.attribute_names
+      #   # => ["id", "created_at", "updated_at", "name", "age"]
+      def attribute_names
+        @attribute_names ||= if !abstract_class?
+          attribute_types.keys
+        else
+          []
+        end
+      end
+
+      # Returns true if the given attribute exists, otherwise false.
+      #
+      #   class Person < DuckRecord::Base
+      #   end
+      #
+      #   Person.has_attribute?('name')   # => true
+      #   Person.has_attribute?(:age)     # => true
+      #   Person.has_attribute?(:nothing) # => false
+      def has_attribute?(attr_name)
+        attribute_types.key?(attr_name.to_s)
+      end
+    end
+
+    # A Person object with a name attribute can ask <tt>person.respond_to?(:name)</tt>,
+    # <tt>person.respond_to?(:name=)</tt>, and <tt>person.respond_to?(:name?)</tt>
+    # which will all return +true+. It also defines the attribute methods if they have
+    # not been generated.
+    #
+    #   class Person < DuckRecord::Base
+    #   end
+    #
+    #   person = Person.new
+    #   person.respond_to?(:name)    # => true
+    #   person.respond_to?(:name=)   # => true
+    #   person.respond_to?(:name?)   # => true
+    #   person.respond_to?('age')    # => true
+    #   person.respond_to?('age=')   # => true
+    #   person.respond_to?('age?')   # => true
+    #   person.respond_to?(:nothing) # => false
+    def respond_to?(name, include_private = false)
+      return false unless super
+
+      case name
+      when :to_partial_path
+        name = 'to_partial_path'.freeze
+      when :to_model
+        name = 'to_model'.freeze
+      else
+        name = name.to_s
+      end
+
+      # If the result is true then check for the select case.
+      # For queries selecting a subset of columns, return false for unselected columns.
+      # We check defined?(@attributes) not to issue warnings if called on objects that
+      # have been allocated but not yet initialized.
+      if defined?(@attributes) && self.class.attribute_names.include?(name)
+        return has_attribute?(name)
+      end
+
+      true
+    end
+
+    # Returns +true+ if the given attribute is in the attributes hash, otherwise +false+.
+    #
+    #   class Person < DuckRecord::Base
+    #   end
+    #
+    #   person = Person.new
+    #   person.has_attribute?(:name)    # => true
+    #   person.has_attribute?('age')    # => true
+    #   person.has_attribute?(:nothing) # => false
+    def has_attribute?(attr_name)
+      @attributes.key?(attr_name.to_s)
+    end
+
+    # Returns an array of names for the attributes available on this object.
+    #
+    #   class Person < DuckRecord::Base
+    #   end
+    #
+    #   person = Person.new
+    #   person.attribute_names
+    #   # => ["id", "created_at", "updated_at", "name", "age"]
+    def attribute_names
+      @attributes.keys
+    end
+
+    # Returns a hash of all the attributes with their names as keys and the values of the attributes as values.
+    #
+    #   class Person < DuckRecord::Base
+    #   end
+    #
+    #   person = Person.create(name: 'Francesco', age: 22)
+    #   person.attributes
+    #   # => {"id"=>3, "created_at"=>Sun, 21 Oct 2012 04:53:04, "updated_at"=>Sun, 21 Oct 2012 04:53:04, "name"=>"Francesco", "age"=>22}
+    def attributes
+      @attributes.to_hash
+    end
+
+    # Returns an <tt>#inspect</tt>-like string for the value of the
+    # attribute +attr_name+. String attributes are truncated up to 50
+    # characters, Date and Time attributes are returned in the
+    # <tt>:db</tt> format. Other attributes return the value of
+    # <tt>#inspect</tt> without modification.
+    #
+    #   person = Person.create!(name: 'David Heinemeier Hansson ' * 3)
+    #
+    #   person.attribute_for_inspect(:name)
+    #   # => "\"David Heinemeier Hansson David Heinemeier Hansson ...\""
+    #
+    #   person.attribute_for_inspect(:created_at)
+    #   # => "\"2012-10-22 00:15:07\""
+    #
+    #   person.attribute_for_inspect(:tag_ids)
+    #   # => "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]"
+    def attribute_for_inspect(attr_name)
+      value = read_attribute(attr_name)
+
+      if value.is_a?(String) && value.length > 50
+        "#{value[0, 50]}...".inspect
+      elsif value.is_a?(Date) || value.is_a?(Time)
+        %("#{value.to_s(:db)}")
+      else
+        value.inspect
+      end
+    end
+
+    # Returns +true+ if the specified +attribute+ has been set by the user or by a
+    # database load and is neither +nil+ nor <tt>empty?</tt> (the latter only applies
+    # to objects that respond to <tt>empty?</tt>, most notably Strings). Otherwise, +false+.
+    # Note that it always returns +true+ with boolean attributes.
+    #
+    #   class Task < DuckRecord::Base
+    #   end
+    #
+    #   task = Task.new(title: '', is_done: false)
+    #   task.attribute_present?(:title)   # => false
+    #   task.attribute_present?(:is_done) # => true
+    #   task.title = 'Buy milk'
+    #   task.is_done = true
+    #   task.attribute_present?(:title)   # => true
+    #   task.attribute_present?(:is_done) # => true
+    def attribute_present?(attribute)
+      value = _read_attribute(attribute)
+      !value.nil? && !(value.respond_to?(:empty?) && value.empty?)
+    end
+
+    # Returns the value of the attribute identified by <tt>attr_name</tt> after it has been typecast (for example,
+    # "2004-12-12" in a date column is cast to a date object, like Date.new(2004, 12, 12)). It raises
+    # <tt>ActiveModel::MissingAttributeError</tt> if the identified attribute is missing.
+    #
+    # Note: +:id+ is always present.
+    #
+    #   class Person < DuckRecord::Base
+    #     belongs_to :organization
+    #   end
+    #
+    #   person = Person.new(name: 'Francesco', age: '22')
+    #   person[:name] # => "Francesco"
+    #   person[:age]  # => 22
+    #
+    #   person = Person.select('id').first
+    #   person[:name]            # => ActiveModel::MissingAttributeError: missing attribute: name
+    #   person[:organization_id] # => ActiveModel::MissingAttributeError: missing attribute: organization_id
+    def [](attr_name)
+      read_attribute(attr_name) { |n| missing_attribute(n, caller) }
+    end
+
+    # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+.
+    # (Alias for the protected #write_attribute method).
+    #
+    #   class Person < DuckRecord::Base
+    #   end
+    #
+    #   person = Person.new
+    #   person[:age] = '22'
+    #   person[:age] # => 22
+    #   person[:age].class # => Integer
+    def []=(attr_name, value)
+      write_attribute(attr_name, value)
+    end
+
+    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
+  end
+end