activemodel 3.0.pre → 3.0.0.rc

data/lib/active_model/version.rb

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

metadata

@@ -1,7 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: activemodel
 version: !ruby/object:Gem::Version 
-  version: 3.0.pre
+  hash: 7712042
+  prerelease: true
+  segments: 
+  - 3
+  - 0
+  - 0
+  - rc
+  version: 3.0.0.rc
 platform: ruby
 authors: 
 - David Heinemeier Hansson
@@ -9,20 +16,59 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-16 00:00:00 -05:00
+date: 2010-07-26 00:00:00 -05: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 
+    none: false
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        version: 3.0.pre
-    version: 
-description: Extracts common modeling concerns from ActiveRecord to share between similar frameworks like ActiveResource.
+        hash: 7712042
+        segments: 
+        - 3
+        - 0
+        - 0
+        - rc
+        version: 3.0.0.rc
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: builder
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 1
+        - 2
+        version: 2.1.2
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: i18n
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 0
+        - 4
+        - 1
+        version: 0.4.1
+  type: :runtime
+  version_requirements: *id003
+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: []
 
@@ -33,26 +79,28 @@ extra_rdoc_files: []
 files: 
 - CHANGELOG
 - MIT-LICENSE
-- README
+- README.rdoc
 - lib/active_model/attribute_methods.rb
+- lib/active_model/callbacks.rb
 - lib/active_model/conversion.rb
 - lib/active_model/deprecated_error_methods.rb
 - lib/active_model/dirty.rb
 - lib/active_model/errors.rb
 - lib/active_model/lint.rb
 - lib/active_model/locale/en.yml
+- lib/active_model/mass_assignment_security/permission_set.rb
+- lib/active_model/mass_assignment_security/sanitizer.rb
+- lib/active_model/mass_assignment_security.rb
 - lib/active_model/naming.rb
 - lib/active_model/observing.rb
+- lib/active_model/railtie.rb
 - lib/active_model/serialization.rb
 - lib/active_model/serializers/json.rb
 - lib/active_model/serializers/xml.rb
-- lib/active_model/state_machine/event.rb
-- lib/active_model/state_machine/machine.rb
-- lib/active_model/state_machine/state.rb
-- lib/active_model/state_machine/state_transition.rb
-- lib/active_model/state_machine.rb
 - lib/active_model/test_case.rb
+- lib/active_model/translation.rb
 - lib/active_model/validations/acceptance.rb
+- lib/active_model/validations/callbacks.rb
 - lib/active_model/validations/confirmation.rb
 - lib/active_model/validations/exclusion.rb
 - lib/active_model/validations/format.rb
@@ -60,9 +108,10 @@ files:
 - lib/active_model/validations/length.rb
 - lib/active_model/validations/numericality.rb
 - lib/active_model/validations/presence.rb
+- lib/active_model/validations/validates.rb
 - lib/active_model/validations/with.rb
 - lib/active_model/validations.rb
-- lib/active_model/validations_repair_helper.rb
+- lib/active_model/validator.rb
 - lib/active_model/version.rb
 - lib/active_model.rb
 has_rdoc: true
@@ -75,23 +124,33 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">"
     - !ruby/object:Gem::Version 
+      hash: 25
+      segments: 
+      - 1
+      - 3
+      - 1
       version: 1.3.1
-  version: 
 requirements: []
 
 rubyforge_project: activemodel
-rubygems_version: 1.3.5
+rubygems_version: 1.3.7
 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: []
 

data/README

@@ -1,21 +0,0 @@
-Active Model
-==============
-
-Totally experimental library that aims to extract common model mixins from
-ActiveRecord for use in ActiveResource (and other similar libraries).  
-This is in a very rough state (no autotest or spec rake tasks set up yet),
-so please excuse the mess.  
-
-Here's what I plan to extract:
-  * ActiveModel::Observing 
-  * ActiveModel::Callbacks
-  * ActiveModel::Validations
-
-	# for ActiveResource params and ActiveRecord options
-  * ActiveModel::Scoping
-
-	# to_json, to_xml, etc
-  * ActiveModel::Serialization
-
-I'm trying to keep ActiveRecord compatibility where possible, but I'm
-annotating the spots where I'm diverging a bit.

data/lib/active_model/state_machine.rb

@@ -1,70 +0,0 @@
-module ActiveModel
-  module StateMachine
-    autoload :Event, 'active_model/state_machine/event'
-    autoload :Machine, 'active_model/state_machine/machine'
-    autoload :State, 'active_model/state_machine/state'
-    autoload :StateTransition, 'active_model/state_machine/state_transition'
-
-    extend ActiveSupport::Concern
-
-    class InvalidTransition < Exception
-    end
-
-    module ClassMethods
-      def inherited(klass)
-        super
-        klass.state_machines = state_machines
-      end
-
-      def state_machines
-        @state_machines ||= {}
-      end
-
-      def state_machines=(value)
-        @state_machines = value ? value.dup : nil
-      end
-
-      def state_machine(name = nil, options = {}, &block)
-        if name.is_a?(Hash)
-          options = name
-          name    = nil
-        end
-        name ||= :default
-        state_machines[name] ||= Machine.new(self, name)
-        block ? state_machines[name].update(options, &block) : state_machines[name]
-      end
-
-      def define_state_query_method(state_name)
-        name = "#{state_name}?"
-        undef_method(name) if method_defined?(name)
-        class_eval "def #{name}; current_state.to_s == %(#{state_name}) end"
-      end
-    end
-
-    def current_state(name = nil, new_state = nil, persist = false)
-      sm   = self.class.state_machine(name)
-      ivar = sm.current_state_variable
-      if name && new_state
-        if persist && respond_to?(:write_state)
-          write_state(sm, new_state)
-        end
-
-        if respond_to?(:write_state_without_persistence)
-          write_state_without_persistence(sm, new_state)
-        end
-
-        instance_variable_set(ivar, new_state)
-      else
-        instance_variable_set(ivar, nil) unless instance_variable_defined?(ivar)
-        value = instance_variable_get(ivar)
-        return value if value
-
-        if respond_to?(:read_state)
-          value = instance_variable_set(ivar, read_state(sm))
-        end
-
-        value || sm.initial_state
-      end
-    end
-  end
-end

data/lib/active_model/state_machine/event.rb

@@ -1,62 +0,0 @@
-module ActiveModel
-  module StateMachine
-    class Event
-      attr_reader :name, :success
-
-      def initialize(machine, name, options = {}, &block)
-        @machine, @name, @transitions = machine, name, []
-        if machine
-          machine.klass.send(:define_method, "#{name}!") do |*args|
-            machine.fire_event(name, self, true, *args)
-          end
-
-          machine.klass.send(:define_method, name.to_s) do |*args|
-            machine.fire_event(name, self, false, *args)
-          end
-        end
-        update(options, &block)
-      end
-
-      def fire(obj, to_state = nil, *args)
-        transitions = @transitions.select { |t| t.from == obj.current_state(@machine ? @machine.name : nil) }
-        raise InvalidTransition if transitions.size == 0
-
-        next_state = nil
-        transitions.each do |transition|
-          next if to_state && !Array(transition.to).include?(to_state)
-          if transition.perform(obj)
-            next_state = to_state || Array(transition.to).first
-            transition.execute(obj, *args)
-            break
-          end
-        end
-        next_state
-      end
-
-      def transitions_from_state?(state)
-        @transitions.any? { |t| t.from? state }
-      end
-
-      def ==(event)
-        if event.is_a? Symbol
-          name == event
-        else
-          name == event.name
-        end
-      end
-
-      def update(options = {}, &block)
-        if options.key?(:success) then @success = options[:success] end
-        if block                  then instance_eval(&block)        end
-        self
-      end
-
-      private
-        def transitions(trans_opts)
-          Array(trans_opts[:from]).each do |s|
-            @transitions << StateTransition.new(trans_opts.merge({:from => s.to_sym}))
-          end
-        end
-    end
-  end
-end

data/lib/active_model/state_machine/machine.rb

@@ -1,75 +0,0 @@
-module ActiveModel
-  module StateMachine
-    class Machine
-      attr_writer :initial_state
-      attr_accessor :states, :events, :state_index
-      attr_reader :klass, :name
-
-      def initialize(klass, name, options = {}, &block)
-        @klass, @name, @states, @state_index, @events = klass, name, [], {}, {}
-        update(options, &block)
-      end
-
-      def initial_state
-        @initial_state ||= (states.first ? states.first.name : nil)
-      end
-
-      def update(options = {}, &block)
-        if options.key?(:initial) then @initial_state = options[:initial] end
-        if block                  then instance_eval(&block)              end
-        self
-      end
-
-      def fire_event(event, record, persist, *args)
-        state_index[record.current_state(@name)].call_action(:exit, record)
-        if new_state = @events[event].fire(record, *args)
-          state_index[new_state].call_action(:enter, record)
-
-          if record.respond_to?(event_fired_callback)
-            record.send(event_fired_callback, record.current_state, new_state)
-          end
-
-          record.current_state(@name, new_state, persist)
-          record.send(@events[event].success) if @events[event].success
-          true
-        else
-          if record.respond_to?(event_failed_callback)
-            record.send(event_failed_callback, event)
-          end
-
-          false
-        end
-      end
-
-      def states_for_select
-        states.map { |st| [st.display_name, st.name.to_s] }
-      end
-
-      def events_for(state)
-        events = @events.values.select { |event| event.transitions_from_state?(state) }
-        events.map! { |event| event.name }
-      end
-
-      def current_state_variable
-        "@#{@name}_current_state"
-      end
-
-      private
-        def state(name, options = {})
-          @states << (state_index[name] ||= State.new(name, :machine => self)).update(options)
-        end
-
-        def event(name, options = {}, &block)
-          (@events[name] ||= Event.new(self, name)).update(options, &block)
-        end
-
-        def event_fired_callback
-          @event_fired_callback ||= (@name == :default ? '' : "#{@name}_") + 'event_fired'
-        end
-
-        def event_failed_callback
-          @event_failed_callback ||= (@name == :default ? '' : "#{@name}_") + 'event_failed'
-        end
-    end
-  end
-end

data/lib/active_model/state_machine/state.rb

@@ -1,47 +0,0 @@
-module ActiveModel
-  module StateMachine
-    class State
-      attr_reader :name, :options
-
-      def initialize(name, options = {})
-        @name = name
-        if machine = options.delete(:machine)
-          machine.klass.define_state_query_method(name)
-        end
-        update(options)
-      end
-
-      def ==(state)
-        if state.is_a? Symbol
-          name == state
-        else
-          name == state.name
-        end
-      end
-
-      def call_action(action, record)
-        action = @options[action]
-        case action
-        when Symbol, String
-          record.send(action)
-        when Proc
-          action.call(record)
-        end
-      end
-
-      def display_name
-        @display_name ||= name.to_s.gsub(/_/, ' ').capitalize
-      end
-
-      def for_select
-        [display_name, name.to_s]
-      end
-
-      def update(options = {})
-        if options.key?(:display) then @display_name = options.delete(:display) end
-        @options = options
-        self
-      end
-    end
-  end
-end