activemodel 3.0.0.beta → 3.0.0.beta2

data/CHANGELOG

@@ -1,4 +1,30 @@
-*Edge*
+*Rails 3.0.0 [beta 2] (April 1st, 2010)*
+
+* #new_record? and #destroyed? were removed from ActiveModel::Lint. Use
+  persisted? instead. A model is persisted if it's not a new_record? and it was 
+  not destroyed? [MG]
+
+* Added validations reflection in ActiveModel::Validations [JV]
+
+    Model.validators
+    Model.validators_on(:field)
+
+* #to_key was added to ActiveModel::Lint so we can generate DOM IDs for
+  AMo objects with composite keys [MG]
+
+
+*Rails 3.0.0 [beta 1] (February 4, 2010)*
+
+* ActiveModel::Observer#add_observer!
+
+  It has a custom hook to define after_find that should really be in a
+  ActiveRecord::Observer subclass:
+
+	  def add_observer!(klass)
+	    klass.add_observer(self)
+	    klass.class_eval 'def after_find() end' unless
+				klass.respond_to?(:after_find)
+	  end
 
 * Change the ActiveModel::Base.include_root_in_json default to true for Rails 3 [DHH]
 

data/README

@@ -11,9 +11,9 @@ Active Model is a solution for this problem.
 Active Model provides a known set of interfaces that your objects can implement
 to then present a common interface to the Action Pack helpers.  You can include
 functionality from the following modules:
- 
+
 * Adding attribute magic to your objects
- 
+
     Add prefixes and suffixes to defined attribute methods...
     
     class Person
@@ -34,7 +34,7 @@ functionality from the following modules:
   {Learn more}[link:classes/ActiveModel/AttributeMethods.html]
   
 * Adding callbacks to your objects
- 
+
     class Person
       extend ActiveModel::Callbacks
       define_model_callbacks :create
@@ -50,19 +50,19 @@ functionality from the following modules:
     wrap your create method.
    
   {Learn more}[link:classes/ActiveModel/CallBacks.html]
- 
+
 * For classes that already look like an Active Record object
- 
+
     class Person
       include ActiveModel::Conversion
     end
     
     ...returns the class itself when sent :to_model
- 
+
    {Learn more}[link:classes/ActiveModel/Conversion.html]
- 
+
 * Tracking changes in your object
- 
+
     Provides all the value tracking features implemented by ActiveRecord...
     
     person = Person.new
@@ -77,29 +77,29 @@ functionality from the following modules:
     person.previous_changes # => {'name' => ['bob, 'robert']}
  
   {Learn more}[link:classes/ActiveModel/Dirty.html]
- 
+
 * Adding +errors+ support to your object
- 
+
     Provides the error messages to allow your object to interact with Action Pack
     helpers seamlessly...
     
     class Person
- 
+    
       def initialize
         @errors = ActiveModel::Errors.new(self)
       end
- 
+    
       attr_accessor :name
       attr_reader   :errors
- 
+    
       def validate!
         errors.add(:name, "can not be nil") if name == nil
       end
- 
+    
       def ErrorsPerson.human_attribute_name(attr, options = {})
         "Name"
       end
- 
+    
     end
     
     ... gives you...
@@ -108,18 +108,18 @@ functionality from the following modules:
     # => ["Name Can not be nil"]
     person.errors.full_messages
     # => ["Name Can not be nil"]
- 
+
   {Learn more}[link:classes/ActiveModel/Errors.html]
- 
+
 * Testing the compliance of your object
- 
+
     Use ActiveModel::Lint to test the compliance of your object to the
     basic ActiveModel API...
     
   {Learn more}[link:classes/ActiveModel/Lint/Tests.html]
- 
+
 * Providing a human face to your object
- 
+
     ActiveModel::Naming provides your model with the model_name convention
     and a human_name attribute...
     
@@ -131,19 +131,19 @@ functionality from the following modules:
     
     NamedPerson.model_name        #=> "NamedPerson"
     NamedPerson.model_name.human  #=> "Named person"
- 
+
   {Learn more}[link:classes/ActiveModel/Naming.html]
- 
+
 * Adding observer support to your objects
- 
+
     ActiveModel::Observers allows your object to implement the Observer
     pattern in a Rails App and take advantage of all the standard observer
     functions.
   
   {Learn more}[link:classes/ActiveModel/Observer.html]
- 
+
 * Making your object serializable
- 
+
     ActiveModel::Serialization provides a standard interface for your object
     to provide to_json or to_xml serialization...
     
@@ -153,48 +153,37 @@ functionality from the following modules:
     s.to_xml              # => "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<serial-person...
   
   {Learn more}[link:classes/ActiveModel/Serialization.html]
-    
- 
-* Turning your object into a finite State Machine
- 
-    ActiveModel::StateMachine provides a clean way to include all the methods
-    you need to transform your object into a finite State Machine...
- 
-    light = TrafficLight.new
-    light.current_state       #=> :red
-    light.change_color!       #=> true
-    light.current_state       #=> :green
- 
-  {Learn more}[link:classes/ActiveModel/StateMachine.html]
- 
+
 * Integrating with Rail's internationalization (i18n) handling through
   ActiveModel::Translations...
- 
+
     class Person
       extend ActiveModel::Translation
     end
   
   {Learn more}[link:classes/ActiveModel/Translation.html]
- 
+
 * Providing a full Validation stack for your objects...
- 
+
    class Person
      include ActiveModel::Validations
- 
+
      attr_accessor :first_name, :last_name
- 
+
+
      validates_each :first_name, :last_name do |record, attr, value|
        record.errors.add attr, 'starts with z.' if value.to_s[0] == ?z
      end
    end
- 
+
+
    person = Person.new(:first_name => 'zoolander')
    person.valid?          #=> false
- 
+
   {Learn more}[link:classes/ActiveModel/Validations.html]
   
 * Make custom validators
- 
+
    class Person
      include ActiveModel::Validations
      validates_with HasNameValidator
@@ -212,5 +201,5 @@ functionality from the following modules:
    p.errors.full_messages    #=> ["Name must exist"]
    p.name = "Bob"
    p.valid?                  #=>  true
- 
+
   {Learn more}[link:classes/ActiveModel/Validator.html]

data/lib/active_model/attribute_methods.rb

@@ -21,7 +21,6 @@ module ActiveModel
   # A minimal implementation could be:
   # 
   #   class Person
-  #   
   #     include ActiveModel::AttributeMethods
   #     
   #     attribute_method_affix  :prefix => 'reset_', :suffix => '_to_default!'
@@ -44,13 +43,16 @@ module ActiveModel
   #     def reset_attribute_to_default!(attr)
   #       send("#{attr}=", "Default Name")
   #     end
-  #   
   #   end
-  # 
+  #
+  # Please notice that whenever you include ActiveModel::AtributeMethods in your class,
+  # it requires you to implement a <tt>attributes</tt> methods which returns a hash with
+  # each attribute name in your model as hash key and the attribute value as hash value.
+  # Hash keys must be a string.
+  #
   module AttributeMethods
     extend ActiveSupport::Concern
 
-    # Declare and check for suffixed attribute methods.
     module ClassMethods
       # Defines an "attribute" method (like +inheritance_column+ or
       # +table_name+). A new (class) method will be created with the
@@ -86,14 +88,21 @@ module ActiveModel
       #   AttributePerson.inheritance_column
       #   # => 'address_id'
       def define_attr_method(name, value=nil, &block)
-        sing = metaclass
-        sing.send :alias_method, "original_#{name}", name
+        sing = singleton_class
+        sing.class_eval <<-eorb, __FILE__, __LINE__ + 1
+          if method_defined?(:original_#{name})
+            undef :original_#{name}
+          end
+          alias_method :original_#{name}, :#{name}
+        eorb
         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"
+          sing.class_eval <<-eorb, __FILE__, __LINE__ + 1
+            def #{name}; #{value.to_s.inspect}; end
+          eorb
         end
       end
 
@@ -254,8 +263,13 @@ module ActiveModel
               if respond_to?(generate_method)
                 send(generate_method, attr_name)
               else
+                method_name = matcher.method_name(attr_name)
+
                 generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__+1
-                  def #{matcher.method_name(attr_name)}(*args)
+                  if method_defined?(:#{method_name})
+                    undef :#{method_name}
+                  end
+                  def #{method_name}(*args)
                     send(:#{matcher.method_missing_target}, '#{attr_name}', *args)
                   end
                 STR
@@ -283,6 +297,7 @@ module ActiveModel
         end
       end
 
+      # Returns true if the attribute methods defined have been generated.
       def attribute_methods_generated?
         @attribute_methods_generated ||= nil
       end

data/lib/active_model/callbacks.rb

@@ -1,3 +1,4 @@
+require 'active_support/core_ext/array/wrap'
 require 'active_support/callbacks'
 
 module ActiveModel
@@ -91,7 +92,7 @@ module ActiveModel
       options = callbacks.extract_options!
       options = { :terminator => "result == false", :scope => [:kind, :name] }.merge(options)
 
-      types = Array(options.delete(:only))
+      types = Array.wrap(options.delete(:only))
       types = [:before, :around, :after] if types.empty?
 
       callbacks.each do |callback|
@@ -124,10 +125,10 @@ module ActiveModel
         def self.after_#{callback}(*args, &block)
           options = args.extract_options!
           options[:prepend] = true
-          options[:if] = Array(options[:if]) << "!halted && value != false"
+          options[:if] = Array.wrap(options[:if]) << "!halted && value != false"
           set_callback(:#{callback}, :after, *(args << options), &block)
         end
       CALLBACK
     end
   end
-end
+end

data/lib/active_model/conversion.rb

@@ -1,19 +1,44 @@
 module ActiveModel
-  # If your object is already designed to implement all of the Active Model featurs
-  # include this module in your Class.
-  # 
-  #   class MyClass
+  # Handle default conversions: to_model, to_key and to_param.
+  #
+  # == Example
+  #
+  # Let's take for example this non persisted object.
+  #
+  #   class ContactMessage
   #     include ActiveModel::Conversion
+  #
+  #     # ContactMessage are never persisted in the DB
+  #     def persisted?
+  #       false
+  #     end
   #   end
-  # 
-  # Returns self to the <tt>:to_model</tt> method.
-  # 
-  # If your model does not act like an Active Model object, then you should define
-  # <tt>:to_model</tt> yourself returning a proxy object that wraps your object
-  # with Active Model compliant methods.
+  #
+  #   cm = ContactMessage.new
+  #   cm.to_model == self #=> true
+  #   cm.to_key           #=> nil
+  #   cm.to_param         #=> nil
+  #
   module Conversion
+    # If your object is already designed to implement all of the Active Model you can use
+    # the default to_model implementation, which simply returns self.
+    # 
+    # If your model does not act like an Active Model object, then you should define
+    # <tt>:to_model</tt> yourself returning a proxy object that wraps your object
+    # with Active Model compliant methods.
     def to_model
       self
     end
+
+    # Returns an Enumerable of all (primary) key attributes or nil if persisted? is fakse
+    def to_key
+      persisted? ? [id] : nil
+    end
+
+    # Returns a string representing the object's key suitable for use in URLs,
+    # or nil if persisted? is false
+    def to_param
+      to_key ? to_key.join('-') : nil
+    end
   end
 end

data/lib/active_model/dirty.rb

@@ -1,3 +1,8 @@
+require 'active_model/attribute_methods'
+require 'active_support/concern'
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/object/duplicable'
+
 module ActiveModel
   # <tt>ActiveModel::Dirty</tt> provides a way to track changes in your
   # object in the same way as ActiveRecord does.
@@ -86,12 +91,17 @@ module ActiveModel
       attribute_method_affix :prefix => 'reset_', :suffix => '!'
     end
 
+    def initialize(*)
+      @changed_attributes = {}
+      super
+    end
+
     # Do any attributes have unsaved changes?
     #   person.changed? # => false
     #   person.name = 'bob'
     #   person.changed? # => true
     def changed?
-      !changed_attributes.empty?
+      !@changed_attributes.empty?
     end
 
     # List of attributes with unsaved changes.
@@ -99,7 +109,7 @@ module ActiveModel
     #   person.name = 'bob'
     #   person.changed # => ['name']
     def changed
-      changed_attributes.keys
+      @changed_attributes.keys
     end
 
     # Map of changed attrs => [original value, new value].
@@ -107,7 +117,7 @@ module ActiveModel
     #   person.name = 'bob'
     #   person.changes # => { 'name' => ['bill', 'bob'] }
     def changes
-      changed.inject({}) { |h, attr| h[attr] = attribute_change(attr); h }
+      changed.inject(HashWithIndifferentAccess.new){ |h, attr| h[attr] = attribute_change(attr); h }
     end
 
     # Map of attributes that were changed when the model was saved.
@@ -116,33 +126,23 @@ module ActiveModel
     #   person.save
     #   person.previous_changes # => {'name' => ['bob, 'robert']}
     def previous_changes
-      previously_changed_attributes
+      @previously_changed
     end
 
     private
-      # Map of change <tt>attr => original value</tt>.
-      def changed_attributes
-        @changed_attributes ||= {}
-      end
-
-      # Map of fields that were changed when the model was saved
-      def previously_changed_attributes
-        @previously_changed || {}
-      end
-
       # Handle <tt>*_changed?</tt> for +method_missing+.
       def attribute_changed?(attr)
-        changed_attributes.include?(attr)
+        @changed_attributes.include?(attr)
       end
 
       # Handle <tt>*_change</tt> for +method_missing+.
       def attribute_change(attr)
-        [changed_attributes[attr], __send__(attr)] if attribute_changed?(attr)
+        [@changed_attributes[attr], __send__(attr)] if attribute_changed?(attr)
       end
 
       # Handle <tt>*_was</tt> for +method_missing+.
       def attribute_was(attr)
-        attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
+        attribute_changed?(attr) ? @changed_attributes[attr] : __send__(attr)
       end
 
       # Handle <tt>*_will_change!</tt> for +method_missing+.
@@ -153,12 +153,12 @@ module ActiveModel
         rescue TypeError, NoMethodError
         end
 
-        changed_attributes[attr] = value
+        @changed_attributes[attr] = value
       end
 
       # Handle <tt>reset_*!</tt> for +method_missing+.
       def reset_attribute!(attr)
-        __send__("#{attr}=", changed_attributes[attr]) if attribute_changed?(attr)
+        __send__("#{attr}=", @changed_attributes[attr]) if attribute_changed?(attr)
       end
   end
 end

data/lib/active_model/errors.rb

@@ -1,4 +1,6 @@
+require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/object/blank'
 require 'active_support/ordered_hash'
 
 module ActiveModel
@@ -206,7 +208,7 @@ module ActiveModel
       full_messages = []
 
       each do |attribute, messages|
-        messages = Array(messages)
+        messages = Array.wrap(messages)
         next if messages.empty?
 
         if attribute == :base

data/lib/active_model/lint.rb

@@ -13,6 +13,33 @@
 module ActiveModel
   module Lint
     module Tests
+
+      # == Responds to <tt>to_key</tt>
+      #
+      # Returns an Enumerable of all (primary) key attributes
+      # or nil if model.persisted? is false
+      def test_to_key
+        assert model.respond_to?(:to_key), "The model should respond to to_key"
+        def model.persisted?() false end
+        assert model.to_key.nil?
+      end
+
+      # == Responds to <tt>to_param</tt>
+      #
+      # Returns a string representing the object's key suitable for use in URLs
+      # or nil if model.persisted? is false.
+      #
+      # Implementers can decide to either raise an exception or provide a default
+      # in case the record uses a composite primary key. There are no tests for this
+      # behavior in lint because it doesn't make sense to force any of the possible
+      # implementation strategies on the implementer. However, if the resource is
+      # not persisted?, then to_param should always return nil.
+      def test_to_param
+        assert model.respond_to?(:to_param), "The model should respond to to_param"
+        def model.persisted?() false end
+        assert model.to_param.nil?
+      end
+
       # == Responds to <tt>valid?</tt>
       #
       # Returns a boolean that specifies whether the object is in a valid or invalid
@@ -22,21 +49,16 @@ module ActiveModel
         assert_boolean model.valid?, "valid?"
       end
 
-      # == Responds to <tt>new_record?</tt>
+      # == Responds to <tt>persisted?</tt>
       #
       # Returns a boolean that specifies whether the object has been persisted yet.
       # This is used when calculating the URL for an object. If the object is
       # not persisted, a form for that object, for instance, will be POSTed to the
       # collection. If it is persisted, a form for the object will put PUTed to the
       # URL for the object.
-      def test_new_record?
-        assert model.respond_to?(:new_record?), "The model should respond to new_record?"
-        assert_boolean model.new_record?, "new_record?"
-      end
-
-      def test_destroyed?
-        assert model.respond_to?(:destroyed?), "The model should respond to destroyed?"
-        assert_boolean model.destroyed?, "destroyed?"
+      def test_persisted?
+        assert model.respond_to?(:persisted?), "The model should respond to persisted?"
+        assert_boolean model.persisted?, "persisted?"
       end
 
       # == Naming

data/lib/active_model/naming.rb

@@ -1,6 +1,7 @@
 require 'active_support/inflector'
 
 module ActiveModel
+
   class Name < String
     attr_reader :singular, :plural, :element, :collection, :partial_path
     alias_method :cache_key, :collection
@@ -41,7 +42,7 @@ module ActiveModel
   # To implement, just extend ActiveModel::Naming in your object:
   # 
   #   class BookCover
-  #     exten ActiveModel::Naming
+  #     extend ActiveModel::Naming
   #   end
   # 
   #   BookCover.model_name        #=> "BookCover"
@@ -57,4 +58,5 @@ module ActiveModel
       @_model_name ||= ActiveModel::Name.new(self)
     end
   end
+  
 end

data/lib/active_model/serializers/xml.rb

@@ -1,3 +1,4 @@
+require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/class/attribute_accessors'
 require 'active_support/core_ext/hash/conversions'
 
@@ -85,8 +86,8 @@ module ActiveModel
           @options[:except] = Array.wrap(@options[:except]).map { |n| n.to_s }
         end
 
-        # To replicate the behavior in ActiveRecord#attributes,
-        # <tt>:except</tt> takes precedence over <tt>:only</tt>.  If <tt>:only</tt> is not set
+        # To replicate the behavior in ActiveRecord#attributes, <tt>:except</tt> 
+        # takes precedence over <tt>:only</tt>.  If <tt>:only</tt> is not set
         # for a N level model but is set for the N+1 level models,
         # then because <tt>:except</tt> is set to a default value, the second
         # level model can have both <tt>:except</tt> and <tt>:only</tt> set.  So if
@@ -108,7 +109,7 @@ module ActiveModel
         end
 
         def serializable_method_attributes
-          Array(options[:methods]).inject([]) do |methods, name|
+          Array.wrap(options[:methods]).inject([]) do |methods, name|
             methods << MethodAttribute.new(name.to_s, @serializable) if @serializable.respond_to?(name.to_s)
             methods
           end

data/lib/active_model/validations.rb

@@ -1,4 +1,6 @@
 require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/class/attribute'
 require 'active_support/core_ext/hash/keys'
 require 'active_model/errors'
 
@@ -45,6 +47,9 @@ module ActiveModel
     included do
       extend ActiveModel::Translation
       define_callbacks :validate, :scope => :name
+
+      class_attribute :_validators
+      self._validators = Hash.new { |h,k| h[k] = [] }
     end
 
     module ClassMethods
@@ -108,21 +113,31 @@ module ActiveModel
       #     end
       #   end
       #
-      # This usage applies to +validate_on_create+ and +validate_on_update as well+.
       def validate(*args, &block)
         options = args.last
         if options.is_a?(Hash) && options.key?(:on)
-          options[:if] = Array(options[:if])
+          options[:if] = Array.wrap(options[:if])
           options[:if] << "@_on_validate == :#{options[:on]}"
         end
         set_callback(:validate, *args, &block)
       end
-    
-      private
-    
+
+      # List all validators that being used to validate the model using +validates_with+
+      # method.
+      def validators
+        _validators.values.flatten.uniq
+      end
+
+      # List all validators that being used to validate a specific attribute.
+      def validators_on(attribute)
+        _validators[attribute.to_sym]
+      end
+
+    private
+
       def _merge_attributes(attr_names)
         options = attr_names.extract_options!
-        options.merge(:attributes => attr_names)
+        options.merge(:attributes => attr_names.flatten)
       end
     end
 

data/lib/active_model/validations/inclusion.rb

@@ -4,7 +4,7 @@ module ActiveModel
       def check_validity!
          raise ArgumentError, "An object with the method include? is required must be supplied as the " <<
                               ":in option of the configuration hash" unless options[:in].respond_to?(:include?)
-       end
+      end
 
       def validate_each(record, attribute, value)
         return if options[:in].include?(value)

data/lib/active_model/validations/with.rb

@@ -62,6 +62,15 @@ module ActiveModel
         args.each do |klass|
           validator = klass.new(options, &block)
           validator.setup(self) if validator.respond_to?(:setup)
+
+          if validator.respond_to?(:attributes) && !validator.attributes.empty?
+            validator.attributes.each do |attribute|
+              _validators[attribute.to_sym] << validator
+            end
+          else
+            _validators[nil] << validator
+          end
+
           validate(validator, options)
         end
       end

data/lib/active_model/validator.rb

@@ -1,3 +1,7 @@
+require 'active_support/core_ext/array/wrap'
+require "active_support/core_ext/module/anonymous"
+require 'active_support/core_ext/object/blank'
+
 module ActiveModel #:nodoc:
   # A simple base class that can be used along with 
   # +ActiveModel::Validations::ClassMethods.validates_with+
@@ -88,11 +92,27 @@ module ActiveModel #:nodoc:
   class Validator
     attr_reader :options
 
+    # Returns the kind of the validator.
+    #
+    # == Examples
+    #
+    #   PresenceValidator.kind    #=> :presence
+    #   UniquenessValidator.kind  #=> :uniqueness
+    #
+    def self.kind
+      @kind ||= name.split('::').last.underscore.sub(/_validator$/, '').to_sym unless anonymous?
+    end
+
     # Accepts options that will be made availible through the +options+ reader.
     def initialize(options)
       @options = options
     end
 
+    # Return the kind for this validator.
+    def kind
+      self.class.kind
+    end
+
     # Override this method in subclasses with validation logic, adding errors
     # to the records +errors+ array where necessary.
     def validate(record)
@@ -112,7 +132,7 @@ module ActiveModel #:nodoc:
     # +options+ reader, however the <tt>:attributes</tt> option will be removed
     # and instead be made available through the +attributes+ reader.
     def initialize(options)
-      @attributes = Array(options.delete(:attributes))
+      @attributes = Array.wrap(options.delete(:attributes))
       raise ":attributes cannot be blank" if @attributes.empty?
       super
       check_validity!

data/lib/active_model/version.rb

@@ -2,8 +2,9 @@ module ActiveModel
   module VERSION #:nodoc:
     MAJOR = 3
     MINOR = 0
-    TINY  = "0.beta"
+    TINY  = 0
+    BUILD = "beta2"
 
-    STRING = [MAJOR, MINOR, TINY].join('.')
+    STRING = [MAJOR, MINOR, TINY, BUILD].join('.')
   end
 end

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: activemodel
 version: !ruby/object:Gem::Version 
-  version: 3.0.0.beta
+  prerelease: true
+  segments: 
+  - 3
+  - 0
+  - 0
+  - beta2
+  version: 3.0.0.beta2
 platform: ruby
 authors: 
 - David Heinemeier Hansson
@@ -9,20 +15,25 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-03 00:00:00 -08:00
+date: 2010-04-01 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: activesupport
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 3.0.0.beta
-    version: 
-description: Extracts common modeling concerns from ActiveRecord to share between similar frameworks like ActiveResource.
+        segments: 
+        - 3
+        - 0
+        - 0
+        - beta2
+        version: 3.0.0.beta2
+  type: :runtime
+  version_requirements: *id001
+description: A toolkit for building modeling frameworks like Active Record and Active Resource. Rich support for attributes, callbacks, validations, observers, serialization, internationalization, and testing.
 email: david@loudthinking.com
 executables: []
 
@@ -77,20 +88,26 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">"
     - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 1
       version: 1.3.1
-  version: 
 requirements: []
 
 rubyforge_project: activemodel
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: A toolkit for building other modeling frameworks like ActiveRecord
+summary: A toolkit for building modeling frameworks (part of Rails).
 test_files: []