activerecord 1.0.0

data/lib/active_record/fixtures.rb

@@ -0,0 +1,172 @@
+require 'yaml'
+
+# Fixtures are a way of organizing data that you want to test against. Each fixture file is created as a row
+# in the database and created as a hash with column names as keys and data as values. All of these fixture hashes
+# are kept in an overall hash where they can be accessed by their file name.
+#
+# Example:
+#
+# Directory with the fixture files
+#
+#   developers/
+#     david
+#     luke
+#     jamis
+#
+# The file +david+ then contains:
+#
+#   id => 1
+#   name => David Heinemeier Hansson
+#   birthday => 1979-10-15
+#   profession => Systems development
+#
+# Now when we call <tt>@developers = Fixtures.new(ActiveRecord::Base.connection, "developers", "developers/")</tt> all three
+# developers will get inserted into the "developers" table through the active Active Record connection (that must be setup
+# before-hand). And we can now query the fixture data through the <tt>@developers</tt> hash, so <tt>@developers["david"]["name"]</tt>
+# will return <tt>"David Heinemeier Hansson"</tt> and <tt>@developers["david"]["birthday"]</tt> will return <tt>Date.new(1979, 10, 15)</tt>.
+#
+# This can then be used for comparison in a unit test. Something like:
+#
+#   def test_find
+#     assert_equal @developers["david"]["name"], Developer.find(@developers["david"]["id"]).name
+#   end
+#
+# == YAML fixtures
+#
+# Additionally, fixtures supports yaml files.  Like fixture files, these yaml files have a pre-defined format.  The document
+# must be formatted like this:
+#
+# name: david
+# data:
+#  id: 1
+#  name: David Heinemeier Hansson
+#  birthday: 1979-10-15
+#  profession: Systems development
+# ---
+# name: steve
+# data:
+#  id: 2
+#  name: Steve Ross Kellock
+#  birthday: 1974-09-27
+#  profession: guy with keyboard
+#
+# In that file, there's two records.  Each record must have two parts:  'name' and 'data'.  The data that you add
+# must be indented like you see above.
+#
+# Yaml fixtures file names must end with .yaml as in people.yaml or camel.yaml.  The yaml fixtures are placed in the same
+# directory as the normal fixtures and can happy co-exist.  :)
+class Fixtures
+  def self.create_fixtures(fixtures_directory, *table_names)
+    connection = block_given? ? yield : ActiveRecord::Base.connection
+    ActiveRecord::Base.logger.level = Logger::ERROR
+
+    fixtures = [ table_names ].flatten.collect do |table_name|
+      Fixtures.new(connection, table_name, "#{fixtures_directory}/#{table_name}")
+    end
+
+    ActiveRecord::Base.logger.level = Logger::DEBUG
+
+    return fixtures.size > 1 ? fixtures : fixtures.first
+  end
+
+  def initialize(connection, table_name, fixture_path, file_filter = /^\.|CVS|\.yaml/)
+    @connection, @table_name, @fixture_path, @file_filter = connection, table_name, fixture_path, file_filter
+    @fixtures = read_fixtures
+
+    delete_existing_fixtures
+    insert_fixtures
+  end
+
+  # Access a fixture hash by using its file name as the key
+  def [](key)
+    @fixtures[key]
+  end
+
+  # Get the number of fixtures kept in this container
+  def length
+    @fixtures.length
+  end
+
+  private
+    def read_fixtures
+      Dir.entries(@fixture_path).inject({}) do |fixtures, file|
+        # is this a regular fixture file?
+        fixtures[file] = Fixture.new(@fixture_path, file) unless file =~ @file_filter
+        # is this a *.yaml file?
+        if file =~ /\.yaml/
+          YamlFixture.produce( "#{@fixture_path}/#{file}" ).each { |fix| fixtures[fix.yaml_name] = fix }
+        end
+        fixtures
+      end
+    end
+
+    def delete_existing_fixtures
+      @connection.delete "DELETE FROM #{@table_name}"
+    end
+
+    def insert_fixtures
+      @fixtures.values.each do |fixture|
+        @connection.execute "INSERT INTO #{@table_name} (#{fixture.key_list}) VALUES(#{fixture.value_list})"
+      end
+    end
+
+    def []=(key, value)
+      @fixtures[key] = value
+    end
+end
+
+class Fixture #:nodoc:
+  def initialize(fixture_path, file)
+    @fixture_path, @file = fixture_path, file
+    @fixture = read_fixture
+  end
+
+  def [](key)
+    @fixture[key]
+  end
+
+  def to_hash
+    @fixture
+  end
+
+  def key_list
+    @fixture.keys.join(", ")
+  end
+
+  def value_list
+    @fixture.values.map { |v| "'#{v}'" }.join(", ")
+  end
+
+  private
+    def read_fixture
+      IO.readlines("#{@fixture_path}/#{@file}").inject({}) do |fixture, line|
+        key, value = line.split(/ => /)
+        fixture[key.strip] = value.strip
+        fixture
+      end
+    end
+end
+
+# A YamlFixture is like a fixture, but instead of a name to use as
+# a key, it uses a yaml_name.
+class YamlFixture < Fixture #:nodoc:
+  # yaml_name is equivalent to a normal fixture's filename
+  attr_accessor :yaml_name
+
+  # constructor is passed the name & the actual instantiate fixture
+  def initialize(yaml_name, fixture)
+    @yaml_name, @fixture = yaml_name, fixture
+  end
+
+  # given a valid yaml file name, create an array of YamlFixture objects
+  def self.produce( yaml_file_name )
+    results = []
+    yaml_file = File.open( yaml_file_name )
+    YAML::load_documents( yaml_file ) do |doc|
+      f = YamlFixture.new( doc['name'], doc['data'] )
+      results << f
+    end
+    yaml_file.close
+    results
+  end
+end

data/lib/active_record/observer.rb

@@ -0,0 +1,71 @@
+require 'singleton'
+
+module ActiveRecord
+  # Observers can be programmed to react to lifecycle callbacks in another class to implement
+  # trigger-like behavior outside the original class. This is a great way to reduce the clutter that
+  # normally comes when the model class is burdened with excess responsibility that doesn't pertain to
+  # the core and nature of the class. Example:
+  #
+  #   class CommentObserver < ActiveRecord::Observer
+  #     def after_save(comment)
+  #       NotificationServer.send_email("admin@do.com", "New comment was posted", comment)
+  #     end
+  #   end
+  #
+  # This Observer is triggered when a Comment#save is finished and sends a notification about it to the administrator.
+  #
+  # == Observing a class that can't be infered
+  #
+  # Observers will by default be mapped to the class with which they share a name. So CommentObserver will
+  # be tied to observing Comment, ProductManagerObserver to ProductManager, and so on. If you want to name your observer
+  # something else than the class you're interested in observing, you can implement the observed_class class method. Like this:
+  #
+  #   class AuditObserver < ActiveRecord::Observer
+  #     def self.observed_class() Account end
+  #     def after_update(account)
+  #       AuditTrail.new(account, "UPDATED")
+  #     end
+  #   end
+  #
+  # == Observing multiple classes at once
+  #
+  # If the audit observer needs to watch more than one kind of object, this can be specified in an array, like this:
+  #
+  #   class AuditObserver < ActiveRecord::Observer
+  #     def self.observed_class() [ Account, Balance ] end
+  #     def after_update(record)
+  #       AuditTrail.new(record, "UPDATED")
+  #     end
+  #   end
+  #
+  # The AuditObserver will now act on both updates to Account and Balance by treating them both as records.
+  #
+  # The observer can implement callback methods for each of the methods described in the Callbacks module.
+  class Observer
+    include Singleton
+  
+    def initialize
+      [ observed_class ].flatten.each do |klass| 
+        klass.add_observer(self)
+        klass.send(:define_method, :after_find) unless klass.respond_to?(:after_find)
+      end
+    end
+  
+    def update(callback_method, object)
+      send(callback_method, object) if respond_to?(callback_method)
+    end
+    
+    private
+      def observed_class
+        if self.class.respond_to? "observed_class"
+          self.class.observed_class
+        else
+          Object.const_get(infer_observed_class_name)
+        end
+      end
+      
+      def infer_observed_class_name
+        self.class.name.scan(/(.*)Observer/)[0][0]
+      end
+  end
+end

data/lib/active_record/reflection.rb

@@ -0,0 +1,126 @@
+module ActiveRecord
+  module Reflection # :nodoc:
+    def self.append_features(base)
+      super
+      base.extend(ClassMethods)
+
+      base.class_eval do
+        class << self
+          alias_method :composed_of_without_reflection, :composed_of
+
+          def composed_of_with_reflection(part_id, options = {})
+            composed_of_without_reflection(part_id, options)
+            write_inheritable_array "aggregations", [ AggregateReflection.new(part_id, options, self) ]
+          end
+
+          alias_method :composed_of, :composed_of_with_reflection          
+        end
+      end
+      
+      for association_type in %w( belongs_to has_one has_many has_and_belongs_to_many )
+        base.module_eval <<-"end_eval"
+          class << self
+            alias_method :#{association_type}_without_reflection, :#{association_type}
+
+            def #{association_type}_with_reflection(association_id, options = {})
+              #{association_type}_without_reflection(association_id, options)
+              write_inheritable_array "associations", [ AssociationReflection.new(association_id, options, self) ]
+            end
+
+            alias_method :#{association_type}, :#{association_type}_with_reflection          
+          end
+        end_eval
+      end
+    end
+
+    # Reflection allows you to interrogate Active Record classes and objects about their associations and aggregations. 
+    # This information can for example be used in a form builder that took an Active Record object and created input
+    # fields for all of the attributes depending on their type and displayed the associations to other objects.
+    #
+    # You can find the interface for the AggregateReflection and AssociationReflection classes in the abstract MacroReflection class.
+    module ClassMethods
+      # Returns an array of AggregateReflection objects for all the aggregations in the class.
+      def reflect_on_all_aggregations
+        read_inheritable_attribute "aggregations"
+      end
+      
+      # Returns the AggregateReflection object for the named +aggregation+ (use the symbol). Example:
+      #   Account.reflect_on_aggregation(:balance) # returns the balance AggregateReflection
+      def reflect_on_aggregation(aggregation)
+        reflect_on_all_aggregations.find { |reflection| reflection.name == aggregation } unless reflect_on_all_aggregations.nil?
+      end
+
+      # Returns an array of AssociationReflection objects for all the aggregations in the class.
+      def reflect_on_all_associations
+        read_inheritable_attribute "associations"
+      end
+      
+      # Returns the AssociationReflection object for the named +aggregation+ (use the symbol). Example:
+      #   Account.reflect_on_association(:owner) # returns the owner AssociationReflection
+      def reflect_on_association(association)
+        reflect_on_all_associations.find { |reflection| reflection.name == association } unless reflect_on_all_associations.nil?
+      end
+    end
+    
+
+    # Abstract base class for AggregateReflection and AssociationReflection that describes the interface available for both of 
+    # those classes. Objects of AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
+    class MacroReflection
+      attr_reader :active_record
+      def initialize(name, options, active_record)
+        @name, @options, @active_record = name, options, active_record
+      end
+      
+      # Returns the name of the macro, so it would return :balance for "composed_of :balance, :class_name => 'Money'" or
+      # :clients for "has_many :clients".
+      def name
+        @name
+      end
+      
+      # Returns the hash of options used for the macro, so it would return { :class_name => "Money" } for 
+      # "composed_of :balance, :class_name => 'Money'" or {} for "has_many :clients".
+      def options
+        @options
+      end
+      
+      # Returns the class for the macro, so "composed_of :balance, :class_name => 'Money'" would return the Money class and
+      # "has_many :clients" would return the Client class.
+      def klass() end
+      
+      def ==(other_aggregation)
+        name == other_aggregation.name && other_aggregation.options && active_record == other_aggregation.active_record
+      end
+    end
+
+
+    # Holds all the meta-data about an aggregation as it was specified in the Active Record class.
+    class AggregateReflection < MacroReflection #:nodoc:
+      def klass
+        Object.const_get(options[:class_name] || name_to_class_name(name.id2name)) 
+      end
+      
+      private
+        def name_to_class_name(name)
+          name.capitalize.gsub(/_(.)/) { |s| $1.capitalize }
+        end
+    end
+
+    # Holds all the meta-data about an association as it was specified in the Active Record class.
+    class AssociationReflection < MacroReflection #:nodoc:
+      def klass
+        active_record.send(:compute_type, (name_to_class_name(name.id2name)))
+      end
+
+      private
+        def name_to_class_name(name)
+          if name !~ /::/
+            class_name = active_record.send(
+              :type_name_with_module, 
+              (options[:class_name] || active_record.class_name(active_record.table_name_prefix + name + active_record.table_name_suffix))
+            )
+          end
+          return class_name || name
+        end
+    end
+  end
+end

data/lib/active_record/support/class_attribute_accessors.rb

@@ -0,0 +1,43 @@
+# attr_* style accessors for class-variables that can accessed both on an instance and class level.
+class Class #:nodoc:
+  def cattr_reader(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        if ! defined? @@#{sym.id2name}
+          @@#{sym.id2name} = nil
+        end
+        
+        def self.#{sym.id2name}
+          @@#{sym}
+        end
+
+        def #{sym.id2name}
+          self.class.#{sym.id2name}
+        end
+      EOS
+    end
+  end
+  
+  def cattr_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        if ! defined? @@#{sym.id2name}
+          @@#{sym.id2name} = nil
+        end
+        
+        def self.#{sym.id2name}=(obj)
+          @@#{sym.id2name} = obj
+        end
+
+        def #{sym.id2name}=(obj)
+          self.class.#{sym.id2name}=(obj)
+        end
+      EOS
+    end
+  end
+  
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end  
+end

data/lib/active_record/support/class_inheritable_attributes.rb

@@ -0,0 +1,37 @@
+# Allows attributes to be shared within an inheritance hierarchy, but where each descentent gets a copy of
+# their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
+# to, for example, an array without those additions being shared with either their parent, siblings, or
+# children, which is unlike the regular class-level attributes that are shared across the entire hierarchy.
+module ClassInheritableAttributes # :nodoc:
+  def self.append_features(base)
+    super
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods # :nodoc:
+    @@classes ||= {}
+    
+    def inheritable_attributes
+      @@classes[self] ||= {}
+    end
+    
+    def write_inheritable_attribute(key, value)
+      inheritable_attributes[key] = value
+    end
+    
+    def write_inheritable_array(key, elements)
+      write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
+      write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
+    end
+
+    def read_inheritable_attribute(key)
+      inheritable_attributes[key]
+    end
+    
+    private 
+      def inherited(child)
+        @@classes[child] = inheritable_attributes.dup
+      end
+      
+  end
+end