duck_record 0.0.1

data/lib/duck_record/core.rb

@@ -0,0 +1,253 @@
+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
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def allocate
+        define_attribute_methods
+        super
+      end
+
+      def initialize_find_by_cache # :nodoc:
+        @find_by_statement_cache = { true => {}.extend(Mutex_m), false => {}.extend(Mutex_m) }
+      end
+
+      def inherited(child_class) # :nodoc:
+        # initialize cache at class definition for thread safety
+        child_class.initialize_find_by_cache
+        super
+      end
+
+      def initialize_generated_modules # :nodoc:
+        generated_association_methods
+      end
+
+      def generated_association_methods
+        @generated_association_methods ||= begin
+          mod = const_set(:GeneratedAssociationMethods, Module.new)
+          private_constant :GeneratedAssociationMethods
+          include mod
+
+          mod
+        end
+      end
+
+      # Returns a string like 'Post(id:integer, title:string, body:text)'
+      def inspect
+        if abstract_class?
+          "#{super}(abstract)"
+        else
+          super
+        end
+      end
+    end
+
+    # New objects can be instantiated as either empty (pass no construction parameter) or pre-set with
+    # attributes but not yet saved (pass a hash with key names matching the associated table column names).
+    # In both instances, valid attribute keys are determined by the column names of the associated table --
+    # hence you can't have attributes that aren't part of the table columns.
+    #
+    # ==== Example:
+    #   # Instantiates a single new object
+    #   User.new(first_name: 'Jamie')
+    def initialize(attributes = nil)
+      self.class.define_attribute_methods
+      @attributes = self.class._default_attributes.deep_dup
+
+      init_internals
+      initialize_internals_callback
+
+      assign_attributes(attributes) if attributes
+
+      yield self if block_given?
+      _run_initialize_callbacks
+    end
+
+    # Initialize an empty model object from +coder+. +coder+ should be
+    # the result of previously encoding an Active Record model, using
+    # #encode_with.
+    #
+    #   class Post < DuckRecord::Base
+    #   end
+    #
+    #   old_post = Post.new(title: "hello world")
+    #   coder = {}
+    #   old_post.encode_with(coder)
+    #
+    #   post = Post.allocate
+    #   post.init_with(coder)
+    #   post.title # => 'hello world'
+    def init_with(coder)
+      coder = LegacyYamlAdapter.convert(self.class, coder)
+      @attributes = self.class.yaml_encoder.decode(coder)
+
+      init_internals
+
+      self.class.define_attribute_methods
+
+      yield self if block_given?
+
+      _run_find_callbacks
+      _run_initialize_callbacks
+
+      self
+    end
+
+    ##
+    # :method: clone
+    # Identical to Ruby's clone method.  This is a "shallow" copy.  Be warned that your attributes are not copied.
+    # That means that modifying attributes of the clone will modify the original, since they will both point to the
+    # same attributes hash. If you need a copy of your attributes hash, please use the #dup method.
+    #
+    #   user = User.first
+    #   new_user = user.clone
+    #   user.name               # => "Bob"
+    #   new_user.name = "Joe"
+    #   user.name               # => "Joe"
+    #
+    #   user.object_id == new_user.object_id            # => false
+    #   user.name.object_id == new_user.name.object_id  # => true
+    #
+    #   user.name.object_id == user.dup.name.object_id  # => false
+
+    ##
+    # :method: dup
+    # Duped objects have no id assigned and are treated as new records. Note
+    # that this is a "shallow" copy as it copies the object's attributes
+    # only, not its associations. The extent of a "deep" copy is application
+    # specific and is therefore left to the application to implement according
+    # to its need.
+    # The dup method does not preserve the timestamps (created|updated)_(at|on).
+
+    ##
+    def initialize_dup(other) # :nodoc:
+      @attributes = @attributes.deep_dup
+
+      _run_initialize_callbacks
+
+      super
+    end
+
+    # Populate +coder+ with attributes about this record that should be
+    # serialized. The structure of +coder+ defined in this method is
+    # guaranteed to match the structure of +coder+ passed to the #init_with
+    # method.
+    #
+    # Example:
+    #
+    #   class Post < DuckRecord::Base
+    #   end
+    #   coder = {}
+    #   Post.new.encode_with(coder)
+    #   coder # => {"attributes" => {"id" => nil, ... }}
+    def encode_with(coder)
+      self.class.yaml_encoder.encode(@attributes, coder)
+      coder['duck_record_yaml_version'] = 2
+    end
+
+    # Clone and freeze the attributes hash such that associations are still
+    # accessible, even on destroyed records, but cloned models will not be
+    # frozen.
+    def freeze
+      @attributes = @attributes.clone.freeze
+      self
+    end
+
+    # Returns +true+ if the attributes hash has been frozen.
+    def frozen?
+      @attributes.frozen?
+    end
+
+    # Returns +true+ if the record is read only. Records loaded through joins with piggy-back
+    # attributes will be marked as read only since they cannot be saved.
+    def readonly?
+      @readonly
+    end
+
+    # Marks this record as read only.
+    def readonly!
+      @readonly = true
+    end
+
+    # Returns the contents of the record as a nicely formatted string.
+    def inspect
+      # We check defined?(@attributes) not to issue warnings if the object is
+      # allocated but not initialized.
+      inspection = if defined?(@attributes) && @attributes
+        self.class.attribute_names.collect do |name|
+          if has_attribute?(name)
+            "#{name}: #{attribute_for_inspect(name)}"
+          end
+        end.compact.join(', ')
+      else
+        'not initialized'
+      end
+
+      "#<#{self.class} #{inspection}>"
+    end
+
+    # Takes a PP and prettily prints this record to it, allowing you to get a nice result from <tt>pp record</tt>
+    # when pp is required.
+    def pretty_print(pp)
+      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|
+            attribute_value = read_attribute(attribute_name)
+            pp.breakable " "
+            pp.group(1) do
+              pp.text attribute_name
+              pp.text ":"
+              pp.breakable
+              pp.pp attribute_value
+            end
+          end
+        else
+          pp.breakable " "
+          pp.text "not initialized"
+        end
+      end
+    end
+
+    # Returns a hash of the given methods with their names as keys and returned values as values.
+    def slice(*methods)
+      Hash[methods.flatten.map! { |method| [method, public_send(method)] }].with_indifferent_access
+    end
+
+    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
+
+    def init_internals
+      @readonly                 = false
+    end
+
+    def initialize_internals_callback
+    end
+
+    def thaw
+      if frozen?
+        @attributes = @attributes.dup
+      end
+    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/define_callbacks.rb

@@ -0,0 +1,23 @@
+module DuckRecord
+  # This module exists because `DuckRecord::AttributeMethods::Dirty` needs to
+  # define callbacks, but continue to have its version of `save` be the super
+  # method of `DuckRecord::Callbacks`. This will be removed when the removal
+  # of deprecated code removes this need.
+  module DefineCallbacks
+    extend ActiveSupport::Concern
+
+    CALLBACKS = [
+      :after_initialize, :before_validation, :after_validation,
+    ]
+
+    module ClassMethods # :nodoc:
+      include ActiveModel::Callbacks
+    end
+
+    included do
+      include ActiveModel::Validations::Callbacks
+
+      define_model_callbacks :initialize, only: :after
+    end
+  end
+end

data/lib/duck_record/errors.rb

@@ -0,0 +1,44 @@
+module DuckRecord
+  # = Active Record Errors
+  #
+  # Generic Active Record exception class.
+  class DuckRecordError < StandardError
+  end
+
+  # Raised on attempt to update record that is instantiated as read only.
+  class ReadOnlyRecord < DuckRecordError
+  end
+
+  # Raised when attribute has a name reserved by Active Record (when attribute
+  # has name of one of Active Record instance methods).
+  class DangerousAttributeError < DuckRecordError
+  end
+
+  # Raised when unknown attributes are supplied via mass assignment.
+  UnknownAttributeError = ActiveModel::UnknownAttributeError
+
+  # Raised when an error occurred while doing a mass assignment to an attribute through the
+  # {DuckRecord::Base#attributes=}[rdoc-ref:AttributeAssignment#attributes=] method.
+  # The exception has an +attribute+ property that is the name of the offending attribute.
+  class AttributeAssignmentError < DuckRecordError
+    attr_reader :exception, :attribute
+
+    def initialize(message = nil, exception = nil, attribute = nil)
+      super(message)
+      @exception = exception
+      @attribute = attribute
+    end
+  end
+
+  # Raised when there are multiple errors while doing a mass assignment through the
+  # {DuckRecord::Base#attributes=}[rdoc-ref:AttributeAssignment#attributes=]
+  # method. The exception has an +errors+ property that contains an array of AttributeAssignmentError
+  # objects, each corresponding to the error while assigning to an attribute.
+  class MultiparameterAssignmentErrors < DuckRecordError
+    attr_reader :errors
+
+    def initialize(errors = nil)
+      @errors = errors
+    end
+  end
+end

data/lib/duck_record/inheritance.rb

@@ -0,0 +1,130 @@
+require "active_support/core_ext/hash/indifferent_access"
+
+module DuckRecord
+  # == Single table inheritance
+  #
+  # Active Record allows inheritance by storing the name of the class in a column that by
+  # default is named "type" (can be changed by overwriting <tt>Base.inheritance_column</tt>).
+  # This means that an inheritance looking like this:
+  #
+  #   class Company < DuckRecord::Base; end
+  #   class Firm < Company; end
+  #   class Client < Company; end
+  #   class PriorityClient < Client; end
+  #
+  # When you do <tt>Firm.create(name: "37signals")</tt>, this record will be saved in
+  # the companies table with type = "Firm". You can then fetch this row again using
+  # <tt>Company.where(name: '37signals').first</tt> and it will return a Firm object.
+  #
+  # Be aware that because the type column is an attribute on the record every new
+  # subclass will instantly be marked as dirty and the type column will be included
+  # in the list of changed attributes on the record. This is different from non
+  # Single Table Inheritance(STI) classes:
+  #
+  #   Company.new.changed? # => false
+  #   Firm.new.changed?    # => true
+  #   Firm.new.changes     # => {"type"=>["","Firm"]}
+  #
+  # If you don't have a type column defined in your table, single-table inheritance won't
+  # be triggered. In that case, it'll work just like normal subclasses with no special magic
+  # for differentiating between them or reloading the right type with find.
+  #
+  # Note, all the attributes for all the cases are kept in the same table. Read more:
+  # http://www.martinfowler.com/eaaCatalog/singleTableInheritance.html
+  #
+  module Inheritance
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Determines if one of the attributes passed in is the inheritance column,
+      # and if the inheritance column is attr accessible, it initializes an
+      # instance of the given subclass instead of the base class.
+      def new(*args, &block)
+        if abstract_class? || self == Base
+          raise NotImplementedError, "#{self} is an abstract class and cannot be instantiated."
+        end
+
+        super
+      end
+
+      # Returns the class descending directly from DuckRecord::Base, or
+      # an abstract class, if any, in the inheritance hierarchy.
+      #
+      # If A extends DuckRecord::Base, A.base_class will return A. If B descends from A
+      # through some arbitrarily deep hierarchy, B.base_class will return A.
+      #
+      # If B < A and C < B and if A is an abstract_class then both B.base_class
+      # and C.base_class would return B as the answer since A is an abstract_class.
+      def base_class
+        unless self < Base
+          raise DuckRecordError, "#{name} doesn't belong in a hierarchy descending from DuckRecord"
+        end
+
+        if superclass == Base || superclass.abstract_class?
+          self
+        else
+          superclass.base_class
+        end
+      end
+
+      # Set this to true if this is an abstract class (see <tt>abstract_class?</tt>).
+      # If you are using inheritance with DuckRecord and don't want child classes
+      # to utilize the implied STI table name of the parent class, this will need to be true.
+      # For example, given the following:
+      #
+      #   class SuperClass < DuckRecord::Base
+      #     self.abstract_class = true
+      #   end
+      #   class Child < SuperClass
+      #     self.table_name = 'the_table_i_really_want'
+      #   end
+      #
+      #
+      # <tt>self.abstract_class = true</tt> is required to make <tt>Child<.find,.create, or any Arel method></tt> use <tt>the_table_i_really_want</tt> instead of a table called <tt>super_classes</tt>
+      #
+      attr_accessor :abstract_class
+
+      # Returns whether this class is an abstract class or not.
+      def abstract_class?
+        defined?(@abstract_class) && @abstract_class == true
+      end
+
+      def inherited(subclass)
+        subclass.instance_variable_set(:@_type_candidates_cache, Concurrent::Map.new)
+        super
+      end
+
+      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
+
+          # 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
+            end
+          end
+
+          raise NameError.new("uninitialized constant #{candidates.first}", candidates.first)
+        end
+      end
+    end
+  end
+end