From 6f97ad07ded847f29159baf71050c63f04282170 Mon Sep 17 00:00:00 2001
From: Geoff Buesing <gbuesing@gmail.com>
Date: Mon, 3 Aug 2009 21:54:40 -0500
Subject: quoted_date converts time-like objects to
 ActiveRecord::Base.default_timezone before serialization. This allows you to
 use Time.now in find conditions and have it correctly be serialized as the
 current time in UTC when default_timezone == :utc [#2946 state:resolved]

---
 activerecord/CHANGELOG                             |  2 +
 .../connection_adapters/abstract/quoting.rb        |  7 ++-
 activerecord/test/cases/base_test.rb               | 69 ++++++++++++++++++++++
 activerecord/test/cases/finder_test.rb             | 50 ++++++++++++++++
 4 files changed, 127 insertions(+), 1 deletion(-)

(limited to 'activerecord')

diff --git a/activerecord/CHANGELOG b/activerecord/CHANGELOG
index 5515cf6b1a..9adc6b887f 100644
--- a/activerecord/CHANGELOG
+++ b/activerecord/CHANGELOG
@@ -1,5 +1,7 @@
 *Edge*
 
+* quoted_date converts time-like objects to ActiveRecord::Base.default_timezone before serialization. This allows you to use Time.now in find conditions and have it correctly be serialized as the current time in UTC when default_timezone == :utc. #2946 [Geoff Buesing]
+
 * SQLite: drop support for 'dbfile' option in favor of 'database.'  #2363 [Paul Hinze, Jeremy Kemper]
 
 * Added :primary_key option to belongs_to associations.  #765 [Szymon Nowak, Philip Hallstrom, Noel Rocha]
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
index 720fba29e9..8649f96498 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/quoting.rb
@@ -60,7 +60,12 @@ module ActiveRecord
       end
 
       def quoted_date(value)
-        value.to_s(:db)
+        if value.acts_like?(:time)
+          zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+          value.respond_to?(zone_conversion_method) ? value.send(zone_conversion_method) : value
+        else
+          value
+        end.to_s(:db)
       end
 
       def quoted_string_prefix
diff --git a/activerecord/test/cases/base_test.rb b/activerecord/test/cases/base_test.rb
index 7169d93841..82eba81549 100755
--- a/activerecord/test/cases/base_test.rb
+++ b/activerecord/test/cases/base_test.rb
@@ -464,6 +464,60 @@ class BasicsTest < ActiveRecord::TestCase
     end
   end
 
+  def test_preserving_time_objects_with_local_time_conversion_to_default_timezone_utc
+    with_env_tz 'America/New_York' do
+      with_active_record_default_timezone :utc do
+        time = Time.local(2000)
+        topic = Topic.create('written_on' => time)
+        saved_time = Topic.find(topic.id).written_on
+        assert_equal time, saved_time
+        assert_equal [0, 0, 0, 1, 1, 2000, 6, 1, false, "EST"], time.to_a
+        assert_equal [0, 0, 5, 1, 1, 2000, 6, 1, false, "UTC"], saved_time.to_a
+      end
+    end
+  end
+
+  def test_preserving_time_objects_with_time_with_zone_conversion_to_default_timezone_utc
+    with_env_tz 'America/New_York' do
+      with_active_record_default_timezone :utc do
+        Time.use_zone 'Central Time (US & Canada)' do
+          time = Time.zone.local(2000)
+          topic = Topic.create('written_on' => time)
+          saved_time = Topic.find(topic.id).written_on
+          assert_equal time, saved_time
+          assert_equal [0, 0, 0, 1, 1, 2000, 6, 1, false, "CST"], time.to_a
+          assert_equal [0, 0, 6, 1, 1, 2000, 6, 1, false, "UTC"], saved_time.to_a
+        end
+      end
+    end
+  end
+
+  def test_preserving_time_objects_with_utc_time_conversion_to_default_timezone_local
+    with_env_tz 'America/New_York' do
+      time = Time.utc(2000)
+      topic = Topic.create('written_on' => time)
+      saved_time = Topic.find(topic.id).written_on
+      assert_equal time, saved_time
+      assert_equal [0, 0, 0, 1, 1, 2000, 6, 1, false, "UTC"], time.to_a
+      assert_equal [0, 0, 19, 31, 12, 1999, 5, 365, false, "EST"], saved_time.to_a
+    end
+  end
+
+  def test_preserving_time_objects_with_time_with_zone_conversion_to_default_timezone_local
+    with_env_tz 'America/New_York' do
+      with_active_record_default_timezone :local do
+        Time.use_zone 'Central Time (US & Canada)' do
+          time = Time.zone.local(2000)
+          topic = Topic.create('written_on' => time)
+          saved_time = Topic.find(topic.id).written_on
+          assert_equal time, saved_time
+          assert_equal [0, 0, 0, 1, 1, 2000, 6, 1, false, "CST"], time.to_a
+          assert_equal [0, 0, 1, 1, 1, 2000, 6, 1, false, "EST"], saved_time.to_a
+        end
+      end
+    end
+  end
+
   def test_custom_mutator
     topic = Topic.find(1)
     # This mutator is protected in the class definition
@@ -2115,4 +2169,19 @@ class BasicsTest < ActiveRecord::TestCase
   def test_dup
     assert !Minimalistic.new.freeze.dup.frozen?
   end
+
+  protected
+    def with_env_tz(new_tz = 'US/Eastern')
+      old_tz, ENV['TZ'] = ENV['TZ'], new_tz
+      yield
+    ensure
+      old_tz ? ENV['TZ'] = old_tz : ENV.delete('TZ')
+    end
+
+    def with_active_record_default_timezone(zone)
+      old_zone, ActiveRecord::Base.default_timezone = ActiveRecord::Base.default_timezone, zone
+      yield
+    ensure
+      ActiveRecord::Base.default_timezone = old_zone
+    end
 end
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index d8f5695a0f..55ef0d45eb 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -423,6 +423,42 @@ class FinderTest < ActiveRecord::TestCase
     assert_equal customers(:david), found_customer
   end
 
+  def test_condition_utc_time_interpolation_with_default_timezone_local
+    with_env_tz 'America/New_York' do
+      with_active_record_default_timezone :local do
+        topic = Topic.first
+        assert_equal topic, Topic.find(:first, :conditions => ['written_on = ?', topic.written_on.getutc])
+      end
+    end
+  end
+
+  def test_hash_condition_utc_time_interpolation_with_default_timezone_local
+    with_env_tz 'America/New_York' do
+      with_active_record_default_timezone :local do
+        topic = Topic.first
+        assert_equal topic, Topic.find(:first, :conditions => {:written_on => topic.written_on.getutc})
+      end
+    end
+  end
+
+  def test_condition_local_time_interpolation_with_default_timezone_utc
+    with_env_tz 'America/New_York' do
+      with_active_record_default_timezone :utc do
+        topic = Topic.first
+        assert_equal topic, Topic.find(:first, :conditions => ['written_on = ?', topic.written_on.getlocal])
+      end
+    end
+  end
+
+  def test_hash_condition_local_time_interpolation_with_default_timezone_utc
+    with_env_tz 'America/New_York' do
+      with_active_record_default_timezone :utc do
+        topic = Topic.first
+        assert_equal topic, Topic.find(:first, :conditions => {:written_on => topic.written_on.getlocal})
+      end
+    end
+  end
+
   def test_bind_variables
     assert_kind_of Firm, Company.find(:first, :conditions => ["name = ?", "37signals"])
     assert_nil Company.find(:first, :conditions => ["name = ?", "37signals!"])
@@ -1087,4 +1123,18 @@ class FinderTest < ActiveRecord::TestCase
         ActiveRecord::Base.send(:replace_bind_variables, statement, vars)
       end
     end
+
+    def with_env_tz(new_tz = 'US/Eastern')
+      old_tz, ENV['TZ'] = ENV['TZ'], new_tz
+      yield
+    ensure
+      old_tz ? ENV['TZ'] = old_tz : ENV.delete('TZ')
+    end
+
+    def with_active_record_default_timezone(zone)
+      old_zone, ActiveRecord::Base.default_timezone = ActiveRecord::Base.default_timezone, zone
+      yield
+    ensure
+      ActiveRecord::Base.default_timezone = old_zone
+    end
 end
-- 
cgit v1.2.3


From 55d1d12c32a1b99f3f07d2346b49a63650ba2e9d Mon Sep 17 00:00:00 2001
From: Matt Ganderup <matt.ganderup@gmail.com>
Date: Mon, 1 Jun 2009 10:24:15 -0700
Subject: fallback_string_to_date sets Date._parse comp arg to true, so that
 strings with two-digit years, e.g. '1/1/09', are interpreted as modern years
 [#2019 state:resolved]

---
 activerecord/CHANGELOG                                              | 2 ++
 .../connection_adapters/abstract/schema_definitions.rb              | 2 +-
 activerecord/test/cases/date_time_test.rb                           | 6 ++++++
 3 files changed, 9 insertions(+), 1 deletion(-)

(limited to 'activerecord')

diff --git a/activerecord/CHANGELOG b/activerecord/CHANGELOG
index 9adc6b887f..3f350be3e9 100644
--- a/activerecord/CHANGELOG
+++ b/activerecord/CHANGELOG
@@ -1,5 +1,7 @@
 *Edge*
 
+* fallback_string_to_date sets Date._parse comp arg to true, so that strings with two-digit years, e.g. '1/1/09', are interpreted as modern years #2019 [Matt Ganderup]
+
 * quoted_date converts time-like objects to ActiveRecord::Base.default_timezone before serialization. This allows you to use Time.now in find conditions and have it correctly be serialized as the current time in UTC when default_timezone == :utc. #2946 [Geoff Buesing]
 
 * SQLite: drop support for 'dbfile' option in favor of 'database.'  #2363 [Paul Hinze, Jeremy Kemper]
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
index 24c734cddb..f4e8fe6a38 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
@@ -201,7 +201,7 @@ module ActiveRecord
           end
 
           def fallback_string_to_date(string)
-            new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
+            new_date(*::Date._parse(string, true).values_at(:year, :mon, :mday))
           end
 
           def fallback_string_to_time(string)
diff --git a/activerecord/test/cases/date_time_test.rb b/activerecord/test/cases/date_time_test.rb
index 36e1caa0b6..f7527c0c04 100644
--- a/activerecord/test/cases/date_time_test.rb
+++ b/activerecord/test/cases/date_time_test.rb
@@ -34,4 +34,10 @@ class DateTimeTest < ActiveRecord::TestCase
     topic.bonus_time = ''
     assert_nil topic.bonus_time
   end
+
+  def test_two_digit_year
+    topic = Topic.new
+    topic.last_read = '1/1/09'
+    assert_equal Date.new(2009,1,1), topic.last_read
+  end
 end
-- 
cgit v1.2.3


From aad5a30bf25d8a3167afd685fc91c99f4f09cc57 Mon Sep 17 00:00:00 2001
From: Joshua Peek <josh@joshpeek.com>
Date: Tue, 4 Aug 2009 11:03:57 -0500
Subject: Add simple support for ActiveModel's StateMachine for ActiveRecord

---
 activerecord/lib/active_record.rb               |  1 +
 activerecord/lib/active_record/state_machine.rb | 24 ++++++++++++++
 activerecord/test/cases/state_machine_test.rb   | 42 +++++++++++++++++++++++++
 activerecord/test/models/traffic_light.rb       | 27 ++++++++++++++++
 activerecord/test/schema/schema.rb              |  7 +++++
 5 files changed, 101 insertions(+)
 create mode 100644 activerecord/lib/active_record/state_machine.rb
 create mode 100644 activerecord/test/cases/state_machine_test.rb
 create mode 100644 activerecord/test/models/traffic_light.rb

(limited to 'activerecord')

diff --git a/activerecord/lib/active_record.rb b/activerecord/lib/active_record.rb
index 5e9ce0600a..68b0251982 100644
--- a/activerecord/lib/active_record.rb
+++ b/activerecord/lib/active_record.rb
@@ -65,6 +65,7 @@ module ActiveRecord
   autoload :SchemaDumper, 'active_record/schema_dumper'
   autoload :Serialization, 'active_record/serialization'
   autoload :SessionStore, 'active_record/session_store'
+  autoload :StateMachine, 'active_record/state_machine'
   autoload :TestCase, 'active_record/test_case'
   autoload :Timestamp, 'active_record/timestamp'
   autoload :Transactions, 'active_record/transactions'
diff --git a/activerecord/lib/active_record/state_machine.rb b/activerecord/lib/active_record/state_machine.rb
new file mode 100644
index 0000000000..aebd03344a
--- /dev/null
+++ b/activerecord/lib/active_record/state_machine.rb
@@ -0,0 +1,24 @@
+module ActiveRecord
+  module StateMachine #:nodoc:
+    extend ActiveSupport::Concern
+    include ActiveModel::StateMachine
+
+    included do
+      before_validation :set_initial_state
+      validates_presence_of :state
+    end
+
+    protected
+      def write_state(state_machine, state)
+        update_attributes! :state => state.to_s
+      end
+
+      def read_state(state_machine)
+        self.state.to_sym
+      end
+
+      def set_initial_state
+        self.state ||= self.class.state_machine.initial_state.to_s
+      end
+  end
+end
diff --git a/activerecord/test/cases/state_machine_test.rb b/activerecord/test/cases/state_machine_test.rb
new file mode 100644
index 0000000000..5d13668bab
--- /dev/null
+++ b/activerecord/test/cases/state_machine_test.rb
@@ -0,0 +1,42 @@
+require 'cases/helper'
+require 'models/traffic_light'
+
+class StateMachineTest < ActiveRecord::TestCase
+  def setup
+    @light = TrafficLight.create!
+  end
+
+  test "states initial state" do
+    assert @light.off?
+    assert_equal :off, @light.current_state
+  end
+
+  test "transition to a valid state" do
+    @light.reset
+    assert @light.red?
+    assert_equal :red, @light.current_state
+
+    @light.green_on
+    assert @light.green?
+    assert_equal :green, @light.current_state
+  end
+
+  test "transition does not persist state" do
+    @light.reset
+    assert_equal :red, @light.current_state
+    @light.reload
+    assert_equal "off", @light.state
+  end
+
+  test "transition does persists state" do
+    @light.reset!
+    assert_equal :red, @light.current_state
+    @light.reload
+    assert_equal "red", @light.state
+  end
+
+  test "transition to an invalid state" do
+    assert_raise(ActiveModel::StateMachine::InvalidTransition) { @light.yellow_on }
+    assert_equal :off, @light.current_state
+  end
+end
diff --git a/activerecord/test/models/traffic_light.rb b/activerecord/test/models/traffic_light.rb
new file mode 100644
index 0000000000..f8cfddbef9
--- /dev/null
+++ b/activerecord/test/models/traffic_light.rb
@@ -0,0 +1,27 @@
+class TrafficLight < ActiveRecord::Base
+  include ActiveRecord::StateMachine
+
+  state_machine do
+    state :off
+
+    state :red
+    state :green
+    state :yellow
+
+    event :red_on do
+      transitions :to => :red, :from => [:yellow]
+    end
+
+    event :green_on do
+      transitions :to => :green, :from => [:red]
+    end
+
+    event :yellow_on do
+      transitions :to => :yellow, :from => [:green]
+    end
+
+    event :reset do
+      transitions :to => :red, :from => [:off]
+    end
+  end
+end
diff --git a/activerecord/test/schema/schema.rb b/activerecord/test/schema/schema.rb
index 2b7d3856b7..1e47cdbaf6 100644
--- a/activerecord/test/schema/schema.rb
+++ b/activerecord/test/schema/schema.rb
@@ -448,6 +448,13 @@ ActiveRecord::Schema.define do
     t.integer :pet_id, :integer
   end
 
+  create_table :traffic_lights, :force => true do |t|
+    t.string   :location
+    t.string   :state
+    t.datetime :created_at
+    t.datetime :updated_at
+  end
+
   create_table :treasures, :force => true do |t|
     t.column :name, :string
     t.column :looter_id, :integer
-- 
cgit v1.2.3


From c30a0ce3c8f88baebd369180a6e221706e2b5cbf Mon Sep 17 00:00:00 2001
From: Paul Gillard <paulmgillard@gmail.com>
Date: Tue, 4 Aug 2009 16:19:19 -0500
Subject: Modified ActiveRecord::AttributeMethods to allow classes to specify
 attribute method prefixes and/or suffixes. Previously only suffixes were
 allowed.

Signed-off-by: Joshua Peek <josh@joshpeek.com>
---
 .../lib/active_record/attribute_methods.rb         | 154 ++++++++++++++++-----
 .../lib/active_record/attribute_methods/read.rb    |   2 +-
 .../attribute_methods/time_zone_conversion.rb      |   4 +-
 .../lib/active_record/attribute_methods/write.rb   |   2 +-
 activerecord/test/cases/attribute_methods_test.rb  |  94 +++++++++++--
 5 files changed, 200 insertions(+), 56 deletions(-)

(limited to 'activerecord')

diff --git a/activerecord/lib/active_record/attribute_methods.rb b/activerecord/lib/active_record/attribute_methods.rb
index 211b77f514..89a92cd7f7 100644
--- a/activerecord/lib/active_record/attribute_methods.rb
+++ b/activerecord/lib/active_record/attribute_methods.rb
@@ -4,10 +4,62 @@ module ActiveRecord
   module AttributeMethods #:nodoc:
     extend ActiveSupport::Concern
 
+    class AttributeMethodMatcher
+      attr_reader :prefix, :suffix
+      
+      AttributeMethodMatch = Struct.new(:prefix, :base, :suffix)
+
+      def initialize(options = {})
+        options.symbolize_keys!
+        @prefix, @suffix = options[:prefix] || '', options[:suffix] || ''
+        @regex = /^(#{Regexp.escape(@prefix)})(.+?)(#{Regexp.escape(@suffix)})$/
+      end
+
+      def match(method_name)
+        if matchdata = @regex.match(method_name)
+          AttributeMethodMatch.new(matchdata[1], matchdata[2], matchdata[3])
+        else
+          nil
+        end
+      end
+    end
+
     # Declare and check for suffixed attribute methods.
     module ClassMethods
+      # Declares a method available for all attributes with the given prefix.
+      # Uses +method_missing+ and <tt>respond_to?</tt> to rewrite the method.
+      #
+      #   #{prefix}#{attr}(*args, &block)
+      #
+      # to
+      #
+      #   #{prefix}attribute(#{attr}, *args, &block)
+      #
+      # An <tt>#{prefix}attribute</tt> instance method must exist and accept at least
+      # the +attr+ argument.
+      #
+      # For example:
+      #
+      #   class Person < ActiveRecord::Base
+      #     attribute_method_prefix 'clear_'
+      #
+      #     private
+      #       def clear_attribute(attr)
+      #         ...
+      #       end
+      #   end
+      #
+      #   person = Person.find(1)
+      #   person.name          # => 'Gem'
+      #   person.clear_name
+      #   person.name          # => ''
+      def attribute_method_prefix(*prefixes)
+        attribute_method_matchers.concat(prefixes.map { |prefix| AttributeMethodMatcher.new :prefix => prefix })
+        undefine_attribute_methods
+      end
+
       # Declares a method available for all attributes with the given suffix.
-      # Uses +method_missing+ and <tt>respond_to?</tt> to rewrite the method
+      # Uses +method_missing+ and <tt>respond_to?</tt> to rewrite the method.
       #
       #   #{attr}#{suffix}(*args, &block)
       #
@@ -21,24 +73,59 @@ module ActiveRecord
       # For example:
       #
       #   class Person < ActiveRecord::Base
-      #     attribute_method_suffix '_changed?'
+      #     attribute_method_suffix '_short?'
       #
       #     private
-      #       def attribute_changed?(attr)
+      #       def attribute_short?(attr)
       #         ...
       #       end
       #   end
       #
       #   person = Person.find(1)
-      #   person.name_changed?    # => false
-      #   person.name = 'Hubert'
-      #   person.name_changed?    # => true
+      #   person.name           # => 'Gem'
+      #   person.name_short?    # => true
       def attribute_method_suffix(*suffixes)
-        attribute_method_suffixes.concat(suffixes)
-        rebuild_attribute_method_regexp
+        attribute_method_matchers.concat(suffixes.map { |suffix| AttributeMethodMatcher.new :suffix => suffix })
         undefine_attribute_methods
       end
 
+      # Declares a method available for all attributes with the given prefix
+      # and suffix. Uses +method_missing+ and <tt>respond_to?</tt> to rewrite
+      # the method.
+      #
+      #   #{prefix}#{attr}#{suffix}(*args, &block)
+      #
+      # to
+      #
+      #   #{prefix}attribute#{suffix}(#{attr}, *args, &block)
+      #
+      # An <tt>#{prefix}attribute#{suffix}</tt> instance method must exist and
+      # accept at least the +attr+ argument.
+      #
+      # For example:
+      #
+      #   class Person < ActiveRecord::Base
+      #     attribute_method_affix :prefix => 'reset_', :suffix => '_to_default!'
+      #
+      #     private
+      #       def reset_attribute_to_default!(attr)
+      #         ...
+      #       end
+      #   end
+      #
+      #   person = Person.find(1)
+      #   person.name                         # => 'Gem'
+      #   person.reset_name_to_default!
+      #   person.name                         # => 'Gemma'
+      def attribute_method_affix(*affixes)
+        attribute_method_matchers.concat(affixes.map { |affix| AttributeMethodMatcher.new :prefix => affix[:prefix], :suffix => affix[:suffix] })
+        undefine_attribute_methods
+      end
+      
+      def matching_attribute_methods(method_name)
+        attribute_method_matchers.collect { |method| method.match(method_name) }.compact
+      end
+      
       # Defines an "attribute" method (like +inheritance_column+ or
       # +table_name+). A new (class) method will be created with the
       # given name. If a value is specified, the new method will
@@ -69,12 +156,6 @@ module ActiveRecord
         end
       end
 
-      # Returns MatchData if method_name is an attribute method.
-      def match_attribute_method?(method_name)
-        rebuild_attribute_method_regexp unless defined?(@@attribute_method_regexp) && @@attribute_method_regexp
-        @@attribute_method_regexp.match(method_name)
-      end
-
       def generated_methods #:nodoc:
         @generated_methods ||= begin
           mod = Module.new
@@ -88,14 +169,15 @@ module ActiveRecord
       def define_attribute_methods
         return unless generated_methods.instance_methods.empty?
         columns_hash.keys.each do |name|
-          attribute_method_suffixes.each do |suffix|
-            method_name = "#{name}#{suffix}"
+          attribute_method_matchers.each do |method|
+            method_name = "#{method.prefix}#{name}#{method.suffix}"
             unless instance_method_already_implemented?(method_name)
-              generate_method = "define_attribute_method#{suffix}"
+              generate_method = "define_method_#{method.prefix}attribute#{method.suffix}"
+              
               if respond_to?(generate_method)
                 send(generate_method, name)
               else
-                generated_methods.module_eval("def #{method_name}(*args); send(:attribute#{suffix}, '#{name}', *args); end", __FILE__, __LINE__)
+                generated_methods.module_eval("def #{method_name}(*args); send(:#{method.prefix}attribute#{method.suffix}, '#{name}', *args); end", __FILE__, __LINE__)
               end
             end
           end
@@ -120,17 +202,20 @@ module ActiveRecord
       end
 
       private
-        # Suffixes a, ?, c become regexp /(a|\?|c)$/
-        def rebuild_attribute_method_regexp
-          suffixes = attribute_method_suffixes.map { |s| Regexp.escape(s) }
-          @@attribute_method_regexp = /(#{suffixes.join('|')})$/.freeze
-        end
-
-        def attribute_method_suffixes
-          @@attribute_method_suffixes ||= []
+        # Default to *=, *? and *_before_type_cast
+        def attribute_method_matchers
+          @@attribute_method_matchers ||= []
         end
     end
 
+    # Returns a struct representing the matching attribute method.
+    # The struct's attributes are prefix, base and suffix.
+    def match_attribute_method?(method_name)
+      self.class.matching_attribute_methods(method_name).find do |match|
+        match.base == 'id' || @attributes.include?(match.base)
+      end
+    end
+    
     # Allows access to the object attributes, which are held in the <tt>@attributes</tt> hash, as though they
     # were first-class methods. So a Person class with a name attribute can use Person#name and
     # Person#name= and never directly use the attributes hash -- except for multiple assigns with
@@ -152,12 +237,9 @@ module ActiveRecord
         end
       end
 
-      if md = self.class.match_attribute_method?(method_name)
-        attribute_name, method_type = md.pre_match, md.to_s
-        if attribute_name == 'id' || @attributes.include?(attribute_name)
-          guard_private_attribute_method!(method_name, args)
-          return __send__("attribute#{method_type}", attribute_name, *args, &block)
-        end
+      if match = match_attribute_method?(method_name)
+        guard_private_attribute_method!(method_name, args)
+        return __send__("#{match.prefix}attribute#{match.suffix}", match.base, *args, &block)
       end
       super
     end
@@ -171,7 +253,7 @@ module ActiveRecord
       if super
         return true
       elsif !include_private_methods && super(method, true)
-        # If we're here than we haven't found among non-private methods
+        # If we're here then we haven't found among non-private methods
         # but found among all methods. Which means that given method is private.
         return false
       elsif self.class.generated_methods.instance_methods.empty?
@@ -179,10 +261,8 @@ module ActiveRecord
         if self.class.generated_methods.instance_methods.include?(method_name)
           return true
         end
-      end
-
-      if md = self.class.match_attribute_method?(method_name)
-        return true if md.pre_match == 'id' || @attributes.include?(md.pre_match)
+      elsif match_attribute_method?(method_name)
+        return true
       end
       super
     end
diff --git a/activerecord/lib/active_record/attribute_methods/read.rb b/activerecord/lib/active_record/attribute_methods/read.rb
index 6c0bf072e9..90acb769a9 100644
--- a/activerecord/lib/active_record/attribute_methods/read.rb
+++ b/activerecord/lib/active_record/attribute_methods/read.rb
@@ -36,7 +36,7 @@ module ActiveRecord
         end
 
         protected
-          def define_attribute_method(attr_name)
+          def define_method_attribute(attr_name)
             if self.serialized_attributes[attr_name]
               define_read_method_for_serialized_attribute(attr_name)
             else
diff --git a/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb b/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb
index 4438c7543e..b9cfe59971 100644
--- a/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb
+++ b/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb
@@ -15,7 +15,7 @@ module ActiveRecord
         protected
           # Defined for all +datetime+ and +timestamp+ attributes when +time_zone_aware_attributes+ are enabled.
           # This enhanced read method automatically converts the UTC time stored in the database to the time zone stored in Time.zone.
-          def define_attribute_method(attr_name)
+          def define_method_attribute(attr_name)
             if create_time_zone_conversion_attribute?(attr_name, columns_hash[attr_name])
               method_body = <<-EOV
                 def #{attr_name}(reload = false)
@@ -33,7 +33,7 @@ module ActiveRecord
 
           # Defined for all +datetime+ and +timestamp+ attributes when +time_zone_aware_attributes+ are enabled.
           # This enhanced write method will automatically convert the time passed to it to the zone stored in Time.zone.
-          def define_attribute_method=(attr_name)
+          def define_method_attribute=(attr_name)
             if create_time_zone_conversion_attribute?(attr_name, columns_hash[attr_name])
               method_body = <<-EOV
                 def #{attr_name}=(time)
diff --git a/activerecord/lib/active_record/attribute_methods/write.rb b/activerecord/lib/active_record/attribute_methods/write.rb
index c75745c00d..79118855cf 100644
--- a/activerecord/lib/active_record/attribute_methods/write.rb
+++ b/activerecord/lib/active_record/attribute_methods/write.rb
@@ -9,7 +9,7 @@ module ActiveRecord
 
       module ClassMethods
         protected
-          def define_attribute_method=(attr_name)
+          def define_method_attribute=(attr_name)
             generated_methods.module_eval("def #{attr_name}=(new_value); write_attribute('#{attr_name}', new_value); end", __FILE__, __LINE__)
           end
       end
diff --git a/activerecord/test/cases/attribute_methods_test.rb b/activerecord/test/cases/attribute_methods_test.rb
index 168b617fbc..a5f4a67200 100644
--- a/activerecord/test/cases/attribute_methods_test.rb
+++ b/activerecord/test/cases/attribute_methods_test.rb
@@ -4,40 +4,90 @@ require 'models/minimalistic'
 
 class AttributeMethodsTest < ActiveRecord::TestCase
   fixtures :topics
+  
   def setup
-    @old_suffixes = ActiveRecord::Base.send(:attribute_method_suffixes).dup
+    @old_matchers = ActiveRecord::Base.send(:attribute_method_matchers).dup
     @target = Class.new(ActiveRecord::Base)
     @target.table_name = 'topics'
   end
 
   def teardown
-    ActiveRecord::Base.send(:attribute_method_suffixes).clear
-    ActiveRecord::Base.attribute_method_suffix *@old_suffixes
+    ActiveRecord::Base.send(:attribute_method_matchers).clear
+    ActiveRecord::Base.send(:attribute_method_matchers).concat(@old_matchers)
   end
 
-  def test_match_attribute_method_query_returns_match_data
-    assert_not_nil md = @target.match_attribute_method?('title=')
-    assert_equal 'title', md.pre_match
-    assert_equal ['='], md.captures
-
-    %w(_hello_world ist! _maybe?).each do |suffix|
+  def test_match_attribute_method_query_returns_default_match_data
+    topic = @target.new(:title => 'Budget')
+    assert_not_nil match = topic.match_attribute_method?('title=')
+    assert_equal '', match.prefix
+    assert_equal 'title', match.base
+    assert_equal '=', match.suffix
+  end
+  
+  def test_match_attribute_method_query_returns_match_data_for_prefixes
+    topic = @target.new(:title => 'Budget')
+    %w(default_ title_).each do |prefix|
+      @target.class_eval "def #{prefix}attribute(*args) args end"
+      @target.attribute_method_prefix prefix
+
+      assert_not_nil match = topic.match_attribute_method?("#{prefix}title")
+      assert_equal prefix, match.prefix
+      assert_equal 'title', match.base
+      assert_equal '', match.suffix
+    end
+  end
+  
+  def test_match_attribute_method_query_returns_match_data_for_suffixes
+    topic = @target.new(:title => 'Budget')
+    %w(_default _title_default it! _candidate=  _maybe?).each do |suffix|
       @target.class_eval "def attribute#{suffix}(*args) args end"
       @target.attribute_method_suffix suffix
 
-      assert_not_nil md = @target.match_attribute_method?("title#{suffix}")
-      assert_equal 'title', md.pre_match
-      assert_equal [suffix], md.captures
+      assert_not_nil match = topic.match_attribute_method?("title#{suffix}")
+      assert_equal '', match.prefix
+      assert_equal 'title', match.base
+      assert_equal suffix, match.suffix
     end
   end
-
-  def test_declared_attribute_method_affects_respond_to_and_method_missing
+  
+  def test_match_attribute_method_query_returns_match_data_for_affixes
+    topic = @target.new(:title => 'Budget')
+    [['mark_', '_for_update'], ['reset_', '!'], ['default_', '_value?']].each do |prefix, suffix|
+      @target.class_eval "def #{prefix}attribute#{suffix}(*args) args end"
+      @target.attribute_method_affix({ :prefix => prefix, :suffix => suffix })
+
+      assert_not_nil match = topic.match_attribute_method?("#{prefix}title#{suffix}")
+      assert_equal prefix, match.prefix
+      assert_equal 'title', match.base
+      assert_equal suffix, match.suffix
+    end
+  end
+  
+  def test_undeclared_attribute_method_does_not_affect_respond_to_and_method_missing
     topic = @target.new(:title => 'Budget')
     assert topic.respond_to?('title')
     assert_equal 'Budget', topic.title
     assert !topic.respond_to?('title_hello_world')
     assert_raise(NoMethodError) { topic.title_hello_world }
+  end
 
-    %w(_hello_world _it! _candidate= able?).each do |suffix|
+  def test_declared_prefixed_attribute_method_affects_respond_to_and_method_missing
+    topic = @target.new(:title => 'Budget')
+    %w(default_ title_).each do |prefix|
+      @target.class_eval "def #{prefix}attribute(*args) args end"
+      @target.attribute_method_prefix prefix
+
+      meth = "#{prefix}title"
+      assert topic.respond_to?(meth)
+      assert_equal ['title'], topic.send(meth)
+      assert_equal ['title', 'a'], topic.send(meth, 'a')
+      assert_equal ['title', 1, 2, 3], topic.send(meth, 1, 2, 3)
+    end
+  end
+
+  def test_declared_suffixed_attribute_method_affects_respond_to_and_method_missing
+    topic = @target.new(:title => 'Budget')
+    %w(_default _title_default _it! _candidate= able?).each do |suffix|
       @target.class_eval "def attribute#{suffix}(*args) args end"
       @target.attribute_method_suffix suffix
 
@@ -49,6 +99,20 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
+  def test_declared_affixed_attribute_method_affects_respond_to_and_method_missing
+    topic = @target.new(:title => 'Budget')
+    [['mark_', '_for_update'], ['reset_', '!'], ['default_', '_value?']].each do |prefix, suffix|
+      @target.class_eval "def #{prefix}attribute#{suffix}(*args) args end"
+      @target.attribute_method_affix({ :prefix => prefix, :suffix => suffix })
+
+      meth = "#{prefix}title#{suffix}"
+      assert topic.respond_to?(meth)
+      assert_equal ['title'], topic.send(meth)
+      assert_equal ['title', 'a'], topic.send(meth, 'a')
+      assert_equal ['title', 1, 2, 3], topic.send(meth, 1, 2, 3)
+    end
+  end
+
   def test_should_unserialize_attributes_for_frozen_records
     myobj = {:value1 => :value2}
     topic = Topic.create("content" => myobj)
-- 
cgit v1.2.3


From bada18dc36e3875dea1814ffaab1e8d1ac24b521 Mon Sep 17 00:00:00 2001
From: Paul Gillard <paulmgillard@gmail.com>
Date: Tue, 4 Aug 2009 16:23:08 -0500
Subject: Added reset_attribute! method to
 ActiveRecord::AttributeMethods::Dirty which will reset an attribute to its
 original value should it have changed.

Signed-off-by: Joshua Peek <josh@joshpeek.com>
---
 .../lib/active_record/attribute_methods/dirty.rb   | 41 +++++++++++++++-------
 activerecord/test/cases/dirty_test.rb              | 10 ++++++
 2 files changed, 39 insertions(+), 12 deletions(-)

(limited to 'activerecord')

diff --git a/activerecord/lib/active_record/attribute_methods/dirty.rb b/activerecord/lib/active_record/attribute_methods/dirty.rb
index b88c84938d..9ec1fbeee1 100644
--- a/activerecord/lib/active_record/attribute_methods/dirty.rb
+++ b/activerecord/lib/active_record/attribute_methods/dirty.rb
@@ -3,17 +3,17 @@ module ActiveRecord
     # Track unsaved attribute changes.
     #
     # A newly instantiated object is unchanged:
-    #   person = Person.find_by_name('uncle bob')
+    #   person = Person.find_by_name('Uncle Bob')
     #   person.changed?       # => false
     #
     # Change the name:
     #   person.name = 'Bob'
     #   person.changed?       # => true
     #   person.name_changed?  # => true
-    #   person.name_was       # => 'uncle bob'
-    #   person.name_change    # => ['uncle bob', 'Bob']
+    #   person.name_was       # => 'Uncle Bob'
+    #   person.name_change    # => ['Uncle Bob', 'Bob']
     #   person.name = 'Bill'
-    #   person.name_change    # => ['uncle bob', 'Bill']
+    #   person.name_change    # => ['Uncle Bob', 'Bill']
     #
     # Save the changes:
     #   person.save
@@ -26,21 +26,33 @@ module ActiveRecord
     #   person.name_change    # => nil
     #
     # Which attributes have changed?
-    #   person.name = 'bob'
+    #   person.name = 'Bob'
     #   person.changed        # => ['name']
-    #   person.changes        # => { 'name' => ['Bill', 'bob'] }
+    #   person.changes        # => { 'name' => ['Bill', 'Bob'] }
+    #
+    # Resetting an attribute returns it to its original state:
+    #   person.reset_name!    # => 'Bill'
+    #   person.changed?       # => false
+    #   person.name_changed?  # => false
+    #   person.name           # => 'Bill'
     #
     # Before modifying an attribute in-place:
     #   person.name_will_change!
-    #   person.name << 'by'
-    #   person.name_change    # => ['uncle bob', 'uncle bobby']
+    #   person.name << 'y'
+    #   person.name_change    # => ['Bill', 'Billy']
     module Dirty
       extend ActiveSupport::Concern
 
-      DIRTY_SUFFIXES = ['_changed?', '_change', '_will_change!', '_was']
+      DIRTY_AFFIXES = [
+        { :suffix => '_changed?' },
+        { :suffix => '_change' },
+        { :suffix => '_will_change!' },
+        { :suffix => '_was' },
+        { :prefix => 'reset_', :suffix => '!' }
+      ]
 
       included do
-        attribute_method_suffix *DIRTY_SUFFIXES
+        attribute_method_affix *DIRTY_AFFIXES
 
         alias_method_chain :save,            :dirty
         alias_method_chain :save!,           :dirty
@@ -118,6 +130,11 @@ module ActiveRecord
           attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
         end
 
+        # Handle <tt>reset_*!</tt> for +method_missing+.
+        def reset_attribute!(attr)
+          self[attr] = changed_attributes[attr] if attribute_changed?(attr)
+        end
+
         # Handle <tt>*_will_change!</tt> for +method_missing+.
         def attribute_will_change!(attr)
           changed_attributes[attr] = clone_attribute_value(:read_attribute, attr)
@@ -175,9 +192,9 @@ module ActiveRecord
 
         def alias_attribute_with_dirty(new_name, old_name)
           alias_attribute_without_dirty(new_name, old_name)
-          DIRTY_SUFFIXES.each do |suffix|
+          DIRTY_AFFIXES.each do |affixes|
             module_eval <<-STR, __FILE__, __LINE__+1
-              def #{new_name}#{suffix}; self.#{old_name}#{suffix}; end  # def subject_changed?; self.title_changed?; end
+              def #{affixes[:prefix]}#{new_name}#{affixes[:suffix]}; self.#{affixes[:prefix]}#{old_name}#{affixes[:suffix]}; end  # def reset_subject!; self.reset_title!; end
             STR
           end
         end
diff --git a/activerecord/test/cases/dirty_test.rb b/activerecord/test/cases/dirty_test.rb
index ac95bac4ad..1441421a80 100644
--- a/activerecord/test/cases/dirty_test.rb
+++ b/activerecord/test/cases/dirty_test.rb
@@ -62,6 +62,16 @@ class DirtyTest < ActiveRecord::TestCase
     assert_equal parrot.name_change, parrot.title_change
   end
 
+  def test_reset_attribute!
+    pirate = Pirate.create!(:catchphrase => 'Yar!')
+    pirate.catchphrase = 'Ahoy!'
+
+    pirate.reset_catchphrase!
+    assert_equal "Yar!", pirate.catchphrase
+    assert_equal Hash.new, pirate.changes
+    assert !pirate.catchphrase_changed?
+  end
+
   def test_nullable_number_not_marked_as_changed_if_new_value_is_blank
     pirate = Pirate.new
 
-- 
cgit v1.2.3


From 64eecdd131c93d7d6c8ef9c6a7ae6b9d76c72a8b Mon Sep 17 00:00:00 2001
From: Joshua Peek <josh@joshpeek.com>
Date: Tue, 4 Aug 2009 16:28:44 -0500
Subject: whitespace

---
 activerecord/lib/active_record/attribute_methods.rb | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

(limited to 'activerecord')

diff --git a/activerecord/lib/active_record/attribute_methods.rb b/activerecord/lib/active_record/attribute_methods.rb
index 89a92cd7f7..be275f5cb6 100644
--- a/activerecord/lib/active_record/attribute_methods.rb
+++ b/activerecord/lib/active_record/attribute_methods.rb
@@ -6,7 +6,7 @@ module ActiveRecord
 
     class AttributeMethodMatcher
       attr_reader :prefix, :suffix
-      
+
       AttributeMethodMatch = Struct.new(:prefix, :base, :suffix)
 
       def initialize(options = {})
@@ -121,11 +121,11 @@ module ActiveRecord
         attribute_method_matchers.concat(affixes.map { |affix| AttributeMethodMatcher.new :prefix => affix[:prefix], :suffix => affix[:suffix] })
         undefine_attribute_methods
       end
-      
+
       def matching_attribute_methods(method_name)
         attribute_method_matchers.collect { |method| method.match(method_name) }.compact
       end
-      
+
       # Defines an "attribute" method (like +inheritance_column+ or
       # +table_name+). A new (class) method will be created with the
       # given name. If a value is specified, the new method will
@@ -173,7 +173,7 @@ module ActiveRecord
             method_name = "#{method.prefix}#{name}#{method.suffix}"
             unless instance_method_already_implemented?(method_name)
               generate_method = "define_method_#{method.prefix}attribute#{method.suffix}"
-              
+
               if respond_to?(generate_method)
                 send(generate_method, name)
               else
@@ -215,7 +215,7 @@ module ActiveRecord
         match.base == 'id' || @attributes.include?(match.base)
       end
     end
-    
+
     # Allows access to the object attributes, which are held in the <tt>@attributes</tt> hash, as though they
     # were first-class methods. So a Person class with a name attribute can use Person#name and
     # Person#name= and never directly use the attributes hash -- except for multiple assigns with
-- 
cgit v1.2.3


From f8d3c72c39ad209abca7f3613f91fb3a03805261 Mon Sep 17 00:00:00 2001
From: Joshua Peek <josh@joshpeek.com>
Date: Tue, 4 Aug 2009 23:36:05 -0500
Subject: Extract generic attribute method generation to AMo

---
 .../lib/active_record/attribute_methods.rb         | 251 +--------------------
 .../lib/active_record/attribute_methods/read.rb    |   4 +-
 .../attribute_methods/time_zone_conversion.rb      |   4 +-
 .../lib/active_record/attribute_methods/write.rb   |   2 +-
 activerecord/lib/active_record/base.rb             |   5 -
 activerecord/test/cases/attribute_methods_test.rb  |  47 ----
 activerecord/test/cases/finder_test.rb             |   2 +-
 7 files changed, 16 insertions(+), 299 deletions(-)

(limited to 'activerecord')

diff --git a/activerecord/lib/active_record/attribute_methods.rb b/activerecord/lib/active_record/attribute_methods.rb
index be275f5cb6..ab7ad34b9e 100644
--- a/activerecord/lib/active_record/attribute_methods.rb
+++ b/activerecord/lib/active_record/attribute_methods.rb
@@ -3,191 +3,13 @@ require 'active_support/core_ext/enumerable'
 module ActiveRecord
   module AttributeMethods #:nodoc:
     extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
 
-    class AttributeMethodMatcher
-      attr_reader :prefix, :suffix
-
-      AttributeMethodMatch = Struct.new(:prefix, :base, :suffix)
-
-      def initialize(options = {})
-        options.symbolize_keys!
-        @prefix, @suffix = options[:prefix] || '', options[:suffix] || ''
-        @regex = /^(#{Regexp.escape(@prefix)})(.+?)(#{Regexp.escape(@suffix)})$/
-      end
-
-      def match(method_name)
-        if matchdata = @regex.match(method_name)
-          AttributeMethodMatch.new(matchdata[1], matchdata[2], matchdata[3])
-        else
-          nil
-        end
-      end
-    end
-
-    # Declare and check for suffixed attribute methods.
     module ClassMethods
-      # Declares a method available for all attributes with the given prefix.
-      # Uses +method_missing+ and <tt>respond_to?</tt> to rewrite the method.
-      #
-      #   #{prefix}#{attr}(*args, &block)
-      #
-      # to
-      #
-      #   #{prefix}attribute(#{attr}, *args, &block)
-      #
-      # An <tt>#{prefix}attribute</tt> instance method must exist and accept at least
-      # the +attr+ argument.
-      #
-      # For example:
-      #
-      #   class Person < ActiveRecord::Base
-      #     attribute_method_prefix 'clear_'
-      #
-      #     private
-      #       def clear_attribute(attr)
-      #         ...
-      #       end
-      #   end
-      #
-      #   person = Person.find(1)
-      #   person.name          # => 'Gem'
-      #   person.clear_name
-      #   person.name          # => ''
-      def attribute_method_prefix(*prefixes)
-        attribute_method_matchers.concat(prefixes.map { |prefix| AttributeMethodMatcher.new :prefix => prefix })
-        undefine_attribute_methods
-      end
-
-      # Declares a method available for all attributes with the given suffix.
-      # Uses +method_missing+ and <tt>respond_to?</tt> to rewrite the method.
-      #
-      #   #{attr}#{suffix}(*args, &block)
-      #
-      # to
-      #
-      #   attribute#{suffix}(#{attr}, *args, &block)
-      #
-      # An <tt>attribute#{suffix}</tt> instance method must exist and accept at least
-      # the +attr+ argument.
-      #
-      # For example:
-      #
-      #   class Person < ActiveRecord::Base
-      #     attribute_method_suffix '_short?'
-      #
-      #     private
-      #       def attribute_short?(attr)
-      #         ...
-      #       end
-      #   end
-      #
-      #   person = Person.find(1)
-      #   person.name           # => 'Gem'
-      #   person.name_short?    # => true
-      def attribute_method_suffix(*suffixes)
-        attribute_method_matchers.concat(suffixes.map { |suffix| AttributeMethodMatcher.new :suffix => suffix })
-        undefine_attribute_methods
-      end
-
-      # Declares a method available for all attributes with the given prefix
-      # and suffix. Uses +method_missing+ and <tt>respond_to?</tt> to rewrite
-      # the method.
-      #
-      #   #{prefix}#{attr}#{suffix}(*args, &block)
-      #
-      # to
-      #
-      #   #{prefix}attribute#{suffix}(#{attr}, *args, &block)
-      #
-      # An <tt>#{prefix}attribute#{suffix}</tt> instance method must exist and
-      # accept at least the +attr+ argument.
-      #
-      # For example:
-      #
-      #   class Person < ActiveRecord::Base
-      #     attribute_method_affix :prefix => 'reset_', :suffix => '_to_default!'
-      #
-      #     private
-      #       def reset_attribute_to_default!(attr)
-      #         ...
-      #       end
-      #   end
-      #
-      #   person = Person.find(1)
-      #   person.name                         # => 'Gem'
-      #   person.reset_name_to_default!
-      #   person.name                         # => 'Gemma'
-      def attribute_method_affix(*affixes)
-        attribute_method_matchers.concat(affixes.map { |affix| AttributeMethodMatcher.new :prefix => affix[:prefix], :suffix => affix[:suffix] })
-        undefine_attribute_methods
-      end
-
-      def matching_attribute_methods(method_name)
-        attribute_method_matchers.collect { |method| method.match(method_name) }.compact
-      end
-
-      # Defines an "attribute" method (like +inheritance_column+ or
-      # +table_name+). A new (class) method will be created with the
-      # given name. If a value is specified, the new method will
-      # return that value (as a string). Otherwise, the given block
-      # will be used to compute the value of the method.
-      #
-      # The original method will be aliased, with the new name being
-      # prefixed with "original_". This allows the new method to
-      # access the original value.
-      #
-      # Example:
-      #
-      #   class A < ActiveRecord::Base
-      #     define_attr_method :primary_key, "sysid"
-      #     define_attr_method( :inheritance_column ) do
-      #       original_inheritance_column + "_id"
-      #     end
-      #   end
-      def define_attr_method(name, value=nil, &block)
-        sing = metaclass
-        sing.send :alias_method, "original_#{name}", name
-        if block_given?
-          sing.send :define_method, name, &block
-        else
-          # use eval instead of a block to work around a memory leak in dev
-          # mode in fcgi
-          sing.class_eval "def #{name}; #{value.to_s.inspect}; end"
-        end
-      end
-
-      def generated_methods #:nodoc:
-        @generated_methods ||= begin
-          mod = Module.new
-          include mod
-          mod
-        end
-      end
-
       # Generates all the attribute related methods for columns in the database
       # accessors, mutators and query methods.
       def define_attribute_methods
-        return unless generated_methods.instance_methods.empty?
-        columns_hash.keys.each do |name|
-          attribute_method_matchers.each do |method|
-            method_name = "#{method.prefix}#{name}#{method.suffix}"
-            unless instance_method_already_implemented?(method_name)
-              generate_method = "define_method_#{method.prefix}attribute#{method.suffix}"
-
-              if respond_to?(generate_method)
-                send(generate_method, name)
-              else
-                generated_methods.module_eval("def #{method_name}(*args); send(:#{method.prefix}attribute#{method.suffix}, '#{name}', *args); end", __FILE__, __LINE__)
-              end
-            end
-          end
-        end
-      end
-
-      def undefine_attribute_methods
-        generated_methods.module_eval do
-          instance_methods.each { |m| undef_method(m) }
-        end
+        super(columns_hash.keys)
       end
 
       # Checks whether the method is defined in the model or any of its subclasses
@@ -200,83 +22,30 @@ module ActiveRecord
         raise DangerousAttributeError, "#{method_name} is defined by ActiveRecord" if @@_defined_activerecord_methods.include?(method_name)
         @_defined_class_methods.include?(method_name)
       end
-
-      private
-        # Default to *=, *? and *_before_type_cast
-        def attribute_method_matchers
-          @@attribute_method_matchers ||= []
-        end
-    end
-
-    # Returns a struct representing the matching attribute method.
-    # The struct's attributes are prefix, base and suffix.
-    def match_attribute_method?(method_name)
-      self.class.matching_attribute_methods(method_name).find do |match|
-        match.base == 'id' || @attributes.include?(match.base)
-      end
     end
 
-    # Allows access to the object attributes, which are held in the <tt>@attributes</tt> hash, as though they
-    # were first-class methods. So a Person class with a name attribute can use Person#name and
-    # Person#name= and never directly use the attributes hash -- except for multiple assigns with
-    # ActiveRecord#attributes=. A Milestone class can also ask Milestone#completed? to test that
-    # the completed attribute is not +nil+ or 0.
-    #
-    # It's also possible to instantiate related objects, so a Client class belonging to the clients
-    # table with a +master_id+ foreign key can instantiate master through Client#master.
     def method_missing(method_id, *args, &block)
-      method_name = method_id.to_s
-
       # If we haven't generated any methods yet, generate them, then
       # see if we've created the method we're looking for.
-      if self.class.generated_methods.instance_methods.empty?
+      if !self.class.attribute_methods_generated?
         self.class.define_attribute_methods
+        method_name = method_id.to_s
         guard_private_attribute_method!(method_name, args)
-        if self.class.generated_methods.instance_methods.include?(method_name)
+        if self.class.generated_attribute_methods.instance_methods.include?(method_name)
           return self.send(method_id, *args, &block)
         end
       end
-
-      if match = match_attribute_method?(method_name)
-        guard_private_attribute_method!(method_name, args)
-        return __send__("#{match.prefix}attribute#{match.suffix}", match.base, *args, &block)
-      end
       super
     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+.
-    alias :respond_to_without_attributes? :respond_to?
-    def respond_to?(method, include_private_methods = false)
-      method_name = method.to_s
-      if super
-        return true
-      elsif !include_private_methods && super(method, true)
-        # If we're here then we haven't found among non-private methods
-        # but found among all methods. Which means that given method is private.
-        return false
-      elsif self.class.generated_methods.instance_methods.empty?
-        self.class.define_attribute_methods
-        if self.class.generated_methods.instance_methods.include?(method_name)
-          return true
-        end
-      elsif match_attribute_method?(method_name)
-        return true
-      end
+    def respond_to?(*args)
+      self.class.define_attribute_methods
       super
     end
 
-    private
-      # prevent method_missing from calling private methods with #send
-      def guard_private_attribute_method!(method_name, args)
-        if self.class.private_method_defined?(method_name)
-          raise NoMethodError.new("Attempt to call private method", method_name, args)
-        end
-      end
-
-      def missing_attribute(attr_name, stack)
-        raise ActiveRecord::MissingAttributeError, "missing attribute: #{attr_name}", stack
+    protected
+      def attribute_method?(attr_name)
+        attr_name == 'id' || attributes.include?(attr_name)
       end
   end
 end
diff --git a/activerecord/lib/active_record/attribute_methods/read.rb b/activerecord/lib/active_record/attribute_methods/read.rb
index 90acb769a9..0b7d6d9094 100644
--- a/activerecord/lib/active_record/attribute_methods/read.rb
+++ b/activerecord/lib/active_record/attribute_methods/read.rb
@@ -51,7 +51,7 @@ module ActiveRecord
         private
           # Define read method for serialized attribute.
           def define_read_method_for_serialized_attribute(attr_name)
-            generated_methods.module_eval("def #{attr_name}; unserialize_attribute('#{attr_name}'); end", __FILE__, __LINE__)
+            generated_attribute_methods.module_eval("def #{attr_name}; unserialize_attribute('#{attr_name}'); end", __FILE__, __LINE__)
           end
 
           # Define an attribute reader method.  Cope with nil column.
@@ -66,7 +66,7 @@ module ActiveRecord
             if cache_attribute?(attr_name)
               access_code = "@attributes_cache['#{attr_name}'] ||= (#{access_code})"
             end
-            generated_methods.module_eval("def #{symbol}; #{access_code}; end", __FILE__, __LINE__)
+            generated_attribute_methods.module_eval("def #{symbol}; #{access_code}; end", __FILE__, __LINE__)
           end
       end
 
diff --git a/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb b/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb
index b9cfe59971..a8e3e28a7a 100644
--- a/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb
+++ b/activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb
@@ -25,7 +25,7 @@ module ActiveRecord
                   @attributes_cache['#{attr_name}'] = time.acts_like?(:time) ? time.in_time_zone : time
                 end
               EOV
-              generated_methods.module_eval(method_body, __FILE__, __LINE__)
+              generated_attribute_methods.module_eval(method_body, __FILE__, __LINE__)
             else
               super
             end
@@ -44,7 +44,7 @@ module ActiveRecord
                   write_attribute(:#{attr_name}, time)
                 end
               EOV
-              generated_methods.module_eval(method_body, __FILE__, __LINE__)
+              generated_attribute_methods.module_eval(method_body, __FILE__, __LINE__)
             else
               super
             end
diff --git a/activerecord/lib/active_record/attribute_methods/write.rb b/activerecord/lib/active_record/attribute_methods/write.rb
index 79118855cf..e31acac050 100644
--- a/activerecord/lib/active_record/attribute_methods/write.rb
+++ b/activerecord/lib/active_record/attribute_methods/write.rb
@@ -10,7 +10,7 @@ module ActiveRecord
       module ClassMethods
         protected
           def define_method_attribute=(attr_name)
-            generated_methods.module_eval("def #{attr_name}=(new_value); write_attribute('#{attr_name}', new_value); end", __FILE__, __LINE__)
+            generated_attribute_methods.module_eval("def #{attr_name}=(new_value); write_attribute('#{attr_name}', new_value); end", __FILE__, __LINE__)
           end
       end
 
diff --git a/activerecord/lib/active_record/base.rb b/activerecord/lib/active_record/base.rb
index ce93ea8eee..e358564ead 100755
--- a/activerecord/lib/active_record/base.rb
+++ b/activerecord/lib/active_record/base.rb
@@ -148,11 +148,6 @@ module ActiveRecord #:nodoc:
   class DangerousAttributeError < ActiveRecordError
   end
 
-  # Raised when you've tried to access a column which wasn't loaded by your finder.
-  # Typically this is because <tt>:select</tt> has been specified.
-  class MissingAttributeError < NoMethodError
-  end
-
   # Raised when unknown attributes are supplied via mass assignment.
   class UnknownAttributeError < NoMethodError
   end
diff --git a/activerecord/test/cases/attribute_methods_test.rb b/activerecord/test/cases/attribute_methods_test.rb
index a5f4a67200..ab8768ea3e 100644
--- a/activerecord/test/cases/attribute_methods_test.rb
+++ b/activerecord/test/cases/attribute_methods_test.rb
@@ -16,53 +16,6 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     ActiveRecord::Base.send(:attribute_method_matchers).concat(@old_matchers)
   end
 
-  def test_match_attribute_method_query_returns_default_match_data
-    topic = @target.new(:title => 'Budget')
-    assert_not_nil match = topic.match_attribute_method?('title=')
-    assert_equal '', match.prefix
-    assert_equal 'title', match.base
-    assert_equal '=', match.suffix
-  end
-  
-  def test_match_attribute_method_query_returns_match_data_for_prefixes
-    topic = @target.new(:title => 'Budget')
-    %w(default_ title_).each do |prefix|
-      @target.class_eval "def #{prefix}attribute(*args) args end"
-      @target.attribute_method_prefix prefix
-
-      assert_not_nil match = topic.match_attribute_method?("#{prefix}title")
-      assert_equal prefix, match.prefix
-      assert_equal 'title', match.base
-      assert_equal '', match.suffix
-    end
-  end
-  
-  def test_match_attribute_method_query_returns_match_data_for_suffixes
-    topic = @target.new(:title => 'Budget')
-    %w(_default _title_default it! _candidate=  _maybe?).each do |suffix|
-      @target.class_eval "def attribute#{suffix}(*args) args end"
-      @target.attribute_method_suffix suffix
-
-      assert_not_nil match = topic.match_attribute_method?("title#{suffix}")
-      assert_equal '', match.prefix
-      assert_equal 'title', match.base
-      assert_equal suffix, match.suffix
-    end
-  end
-  
-  def test_match_attribute_method_query_returns_match_data_for_affixes
-    topic = @target.new(:title => 'Budget')
-    [['mark_', '_for_update'], ['reset_', '!'], ['default_', '_value?']].each do |prefix, suffix|
-      @target.class_eval "def #{prefix}attribute#{suffix}(*args) args end"
-      @target.attribute_method_affix({ :prefix => prefix, :suffix => suffix })
-
-      assert_not_nil match = topic.match_attribute_method?("#{prefix}title#{suffix}")
-      assert_equal prefix, match.prefix
-      assert_equal 'title', match.base
-      assert_equal suffix, match.suffix
-    end
-  end
-  
   def test_undeclared_attribute_method_does_not_affect_respond_to_and_method_missing
     topic = @target.new(:title => 'Budget')
     assert topic.respond_to?('title')
diff --git a/activerecord/test/cases/finder_test.rb b/activerecord/test/cases/finder_test.rb
index 55ef0d45eb..893fc34c36 100644
--- a/activerecord/test/cases/finder_test.rb
+++ b/activerecord/test/cases/finder_test.rb
@@ -251,7 +251,7 @@ class FinderTest < ActiveRecord::TestCase
 
   def test_find_only_some_columns
     topic = Topic.find(1, :select => "author_name")
-    assert_raise(ActiveRecord::MissingAttributeError) {topic.title}
+    assert_raise(ActiveModel::MissingAttributeError) {topic.title}
     assert_equal "David", topic.author_name
     assert !topic.attribute_present?("title")
     #assert !topic.respond_to?("title")
-- 
cgit v1.2.3


From bfafe8c4055bcb8dcf7440015d95a32c9773f40b Mon Sep 17 00:00:00 2001
From: Geoff Buesing <gbuesing@gmail.com>
Date: Wed, 5 Aug 2009 08:19:21 -0500
Subject: Revert "fallback_string_to_date sets Date._parse comp arg to true, so
 that strings with two-digit years, e.g. '1/1/09', are interpreted as modern
 years" [#2019 state:wontfix]

This reverts commit 55d1d12c32a1b99f3f07d2346b49a63650ba2e9d.
---
 activerecord/CHANGELOG                                              | 2 --
 .../connection_adapters/abstract/schema_definitions.rb              | 2 +-
 activerecord/test/cases/date_time_test.rb                           | 6 ------
 3 files changed, 1 insertion(+), 9 deletions(-)

(limited to 'activerecord')

diff --git a/activerecord/CHANGELOG b/activerecord/CHANGELOG
index 3f350be3e9..9adc6b887f 100644
--- a/activerecord/CHANGELOG
+++ b/activerecord/CHANGELOG
@@ -1,7 +1,5 @@
 *Edge*
 
-* fallback_string_to_date sets Date._parse comp arg to true, so that strings with two-digit years, e.g. '1/1/09', are interpreted as modern years #2019 [Matt Ganderup]
-
 * quoted_date converts time-like objects to ActiveRecord::Base.default_timezone before serialization. This allows you to use Time.now in find conditions and have it correctly be serialized as the current time in UTC when default_timezone == :utc. #2946 [Geoff Buesing]
 
 * SQLite: drop support for 'dbfile' option in favor of 'database.'  #2363 [Paul Hinze, Jeremy Kemper]
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
index f4e8fe6a38..24c734cddb 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb
@@ -201,7 +201,7 @@ module ActiveRecord
           end
 
           def fallback_string_to_date(string)
-            new_date(*::Date._parse(string, true).values_at(:year, :mon, :mday))
+            new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
           end
 
           def fallback_string_to_time(string)
diff --git a/activerecord/test/cases/date_time_test.rb b/activerecord/test/cases/date_time_test.rb
index f7527c0c04..36e1caa0b6 100644
--- a/activerecord/test/cases/date_time_test.rb
+++ b/activerecord/test/cases/date_time_test.rb
@@ -34,10 +34,4 @@ class DateTimeTest < ActiveRecord::TestCase
     topic.bonus_time = ''
     assert_nil topic.bonus_time
   end
-
-  def test_two_digit_year
-    topic = Topic.new
-    topic.last_read = '1/1/09'
-    assert_equal Date.new(2009,1,1), topic.last_read
-  end
 end
-- 
cgit v1.2.3