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]

---
 .../lib/active_record/connection_adapters/abstract/quoting.rb      | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

(limited to 'activerecord/lib/active_record')

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
-- 
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]

---
 .../active_record/connection_adapters/abstract/schema_definitions.rb    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'activerecord/lib/active_record')

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)
-- 
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/state_machine.rb | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 activerecord/lib/active_record/state_machine.rb

(limited to 'activerecord/lib/active_record')

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
-- 
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 +-
 4 files changed, 121 insertions(+), 41 deletions(-)

(limited to 'activerecord/lib/active_record')

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
-- 
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 +++++++++++++++-------
 1 file changed, 29 insertions(+), 12 deletions(-)

(limited to 'activerecord/lib/active_record')

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
-- 
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/lib/active_record')

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 -
 5 files changed, 15 insertions(+), 251 deletions(-)

(limited to 'activerecord/lib/active_record')

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
-- 
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.
---
 .../active_record/connection_adapters/abstract/schema_definitions.rb    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'activerecord/lib/active_record')

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)
-- 
cgit v1.2.3