activemodel 3.0.0.beta

data/lib/active_model/lint.rb

@@ -0,0 +1,89 @@
+# You can test whether an object is compliant with the ActiveModel API by
+# including ActiveModel::Lint::Tests in your TestCase. It will included
+# tests that tell you whether your object is fully compliant, or if not,
+# which aspects of the API are not implemented.
+#
+# These tests do not attempt to determine the semantic correctness of the
+# returned values. For instance, you could implement valid? to always
+# return true, and the tests would pass. It is up to you to ensure that
+# the values are semantically meaningful.
+#
+# Objects you pass in are expected to return a compliant object from a
+# call to to_model. It is perfectly fine for to_model to return self.
+module ActiveModel
+  module Lint
+    module Tests
+      # == Responds to <tt>valid?</tt>
+      #
+      # Returns a boolean that specifies whether the object is in a valid or invalid
+      # state.
+      def test_valid?
+        assert model.respond_to?(:valid?), "The model should respond to valid?"
+        assert_boolean model.valid?, "valid?"
+      end
+
+      # == Responds to <tt>new_record?</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?"
+      end
+
+      # == Naming
+      #
+      # Model.model_name must returns a string with some convenience methods as
+      # :human and :partial_path. Check ActiveModel::Naming for more information.
+      #
+      def test_model_naming
+        assert model.class.respond_to?(:model_name), "The model should respond to model_name"
+        model_name = model.class.model_name
+        assert_kind_of String, model_name
+        assert_kind_of String, model_name.human
+        assert_kind_of String, model_name.partial_path
+        assert_kind_of String, model_name.singular
+        assert_kind_of String, model_name.plural
+      end
+
+      # == Errors Testing
+      # 
+      # Returns an object that has :[] and :full_messages defined on it. See below
+      # for more details.
+      #
+      # Returns an Array of Strings that are the errors for the attribute in
+      # question. If localization is used, the Strings should be localized
+      # for the current locale. If no error is present, this method should
+      # return an empty Array.
+      def test_errors_aref
+        assert model.respond_to?(:errors), "The model should respond to errors"
+        assert model.errors[:hello].is_a?(Array), "errors#[] should return an Array"
+      end
+
+      # Returns an Array of all error messages for the object. Each message
+      # should contain information about the field, if applicable.
+      def test_errors_full_messages
+        assert model.respond_to?(:errors), "The model should respond to errors"
+        assert model.errors.full_messages.is_a?(Array), "errors#full_messages should return an Array"
+      end
+
+      private
+        def model
+          assert @model.respond_to?(:to_model), "The object should respond_to to_model"
+          @model.to_model
+        end
+
+        def assert_boolean(result, name)
+          assert result == true || result == false, "#{name} should be a boolean"
+        end
+    end
+  end
+end

data/lib/active_model/locale/en.yml

@@ -0,0 +1,26 @@
+en:
+  errors:
+    # The default format use in full error messages.
+    format: "{{attribute}} {{message}}"
+
+    # The values :model, :attribute and :value are always available for interpolation
+    # The value :count is available when applicable. Can be used for pluralization.
+    messages:
+      inclusion: "is not included in the list"
+      exclusion: "is reserved"
+      invalid: "is invalid"
+      confirmation: "doesn't match confirmation"
+      accepted: "must be accepted"
+      empty: "can't be empty"
+      blank: "can't be blank"
+      too_long: "is too long (maximum is {{count}} characters)"
+      too_short: "is too short (minimum is {{count}} characters)"
+      wrong_length: "is the wrong length (should be {{count}} characters)"
+      not_a_number: "is not a number"
+      greater_than: "must be greater than {{count}}"
+      greater_than_or_equal_to: "must be greater than or equal to {{count}}"
+      equal_to: "must be equal to {{count}}"
+      less_than: "must be less than {{count}}"
+      less_than_or_equal_to: "must be less than or equal to {{count}}"
+      odd: "must be odd"
+      even: "must be even"

data/lib/active_model/naming.rb

@@ -0,0 +1,60 @@
+require 'active_support/inflector'
+
+module ActiveModel
+  class Name < String
+    attr_reader :singular, :plural, :element, :collection, :partial_path
+    alias_method :cache_key, :collection
+
+    def initialize(klass)
+      super(klass.name)
+      @klass = klass
+      @singular = ActiveSupport::Inflector.underscore(self).tr('/', '_').freeze
+      @plural = ActiveSupport::Inflector.pluralize(@singular).freeze
+      @element = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(self)).freeze
+      @human = ActiveSupport::Inflector.humanize(@element).freeze
+      @collection = ActiveSupport::Inflector.tableize(self).freeze
+      @partial_path = "#{@collection}/#{@element}".freeze
+    end
+
+    # Transform the model name into a more humane format, using I18n. By default,
+    # it will underscore then humanize the class name (BlogPost.model_name.human #=> "Blog post").
+    # Specify +options+ with additional translating options.
+    def human(options={})
+      return @human unless @klass.respond_to?(:lookup_ancestors) &&
+                           @klass.respond_to?(:i18n_scope)
+
+      defaults = @klass.lookup_ancestors.map do |klass|
+        klass.model_name.underscore.to_sym
+      end
+
+      defaults << options.delete(:default) if options[:default]
+      defaults << @human
+
+      options.reverse_merge! :scope => [@klass.i18n_scope, :models], :count => 1, :default => defaults
+      I18n.translate(defaults.shift, options)
+    end
+  end
+
+  # ActiveModel::Naming is a module that creates a +model_name+ method on your
+  # object.
+  # 
+  # To implement, just extend ActiveModel::Naming in your object:
+  # 
+  #   class BookCover
+  #     exten ActiveModel::Naming
+  #   end
+  # 
+  #   BookCover.model_name        #=> "BookCover"
+  #   BookCover.model_name.human  #=> "Book cover"
+  # 
+  # Providing the functionality that ActiveModel::Naming provides in your object
+  # is required to pass the ActiveModel Lint test.  So either extending the provided
+  # method below, or rolling your own is required..
+  module Naming
+    # Returns an ActiveModel::Name object for module. It can be
+    # used to retrieve all kinds of naming-related information.
+    def model_name
+      @_model_name ||= ActiveModel::Name.new(self)
+    end
+  end
+end

data/lib/active_model/observing.rb

@@ -0,0 +1,196 @@
+require 'observer'
+require 'singleton'
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/core_ext/string/inflections'
+
+module ActiveModel
+  module Observing
+    extend ActiveSupport::Concern
+
+    included do
+      extend Observable
+    end
+
+    module ClassMethods
+      # Activates the observers assigned. Examples:
+      #
+      #   # Calls PersonObserver.instance
+      #   ActiveRecord::Base.observers = :person_observer
+      #
+      #   # Calls Cacher.instance and GarbageCollector.instance
+      #   ActiveRecord::Base.observers = :cacher, :garbage_collector
+      #
+      #   # Same as above, just using explicit class references
+      #   ActiveRecord::Base.observers = Cacher, GarbageCollector
+      #
+      # Note: Setting this does not instantiate the observers yet. 
+      # +instantiate_observers+ is called during startup, and before
+      # each development request.
+      def observers=(*values)
+        @observers = values.flatten
+      end
+
+      # Gets the current observers.
+      def observers
+        @observers ||= []
+      end
+
+      # Instantiate the global Active Record observers.
+      def instantiate_observers
+        observers.each { |o| instantiate_observer(o) }
+      end
+
+      protected
+        def instantiate_observer(observer) #:nodoc:
+          # string/symbol
+          if observer.respond_to?(:to_sym)
+            observer = observer.to_s.camelize.constantize.instance
+          elsif observer.respond_to?(:instance)
+            observer.instance
+          else
+            raise ArgumentError, "#{observer} must be a lowercase, underscored class name (or an instance of the class itself) responding to the instance method. Example: Person.observers = :big_brother # calls BigBrother.instance"
+          end
+        end
+
+        # Notify observers when the observed class is subclassed.
+        def inherited(subclass)
+          super
+          changed
+          notify_observers :observed_class_inherited, subclass
+        end
+    end
+
+    private
+      # Fires notifications to model's observers
+      #
+      # def save
+      #   notify_observers(:before_save)
+      #   ...
+      #   notify_observers(:after_save)
+      # end
+      def notify_observers(method)
+        self.class.changed
+        self.class.notify_observers(method, self)
+      end
+  end
+
+  # Observer classes respond to lifecycle callbacks to implement trigger-like
+  # behavior outside the original class. This is a great way to reduce the
+  # clutter that normally comes when the model class is burdened with
+  # functionality that doesn't pertain to the core responsibility of the
+  # class. Example:
+  #
+  #   class CommentObserver < ActiveModel::Observer
+  #     def after_save(comment)
+  #       Notifications.deliver_comment("admin@do.com", "New comment was posted", comment)
+  #     end
+  #   end
+  #
+  # This Observer sends an email when a Comment#save is finished.
+  #
+  #   class ContactObserver < ActiveModel::Observer
+  #     def after_create(contact)
+  #       contact.logger.info('New contact added!')
+  #     end
+  #
+  #     def after_destroy(contact)
+  #       contact.logger.warn("Contact with an id of #{contact.id} was destroyed!")
+  #     end
+  #   end
+  #
+  # This Observer uses logger to log when specific callbacks are triggered.
+  #
+  # == Observing a class that can't be inferred
+  #
+  # Observers will by default be mapped to the class with which they share a
+  # name. So CommentObserver will be tied to observing Comment, ProductManagerObserver
+  # to ProductManager, and so on. If you want to name your observer differently than 
+  # the class you're interested in observing, you can use the Observer.observe class 
+  # method which takes either the concrete class (Product) or a symbol for that 
+  # class (:product):
+  #
+  #   class AuditObserver < ActiveModel::Observer
+  #     observe :account
+  #
+  #     def after_update(account)
+  #       AuditTrail.new(account, "UPDATED")
+  #     end
+  #   end
+  #
+  # If the audit observer needs to watch more than one kind of object, this can be 
+  # specified with multiple arguments:
+  #
+  #   class AuditObserver < ActiveModel::Observer
+  #     observe :account, :balance
+  #
+  #     def after_update(record)
+  #       AuditTrail.new(record, "UPDATED")
+  #     end
+  #   end
+  #
+  # The AuditObserver will now act on both updates to Account and Balance by treating 
+  # them both as records.
+  #
+  class Observer
+    include Singleton
+
+    class << self
+      # Attaches the observer to the supplied model classes.
+      def observe(*models)
+        models.flatten!
+        models.collect! { |model| model.respond_to?(:to_sym) ? model.to_s.camelize.constantize : model }
+        define_method(:observed_classes) { models }
+      end
+
+      # Returns an array of Classes to observe.
+      #
+      # You can override this instead of using the +observe+ helper.
+      #
+      #   class AuditObserver < ActiveModel::Observer
+      #     def self.observed_classes
+      #       [Account, Balance]
+      #     end
+      #   end
+      def observed_classes
+        Array.wrap(observed_class)
+      end
+
+      # The class observed by default is inferred from the observer's class name:
+      #   assert_equal Person, PersonObserver.observed_class
+      def observed_class
+        if observed_class_name = name[/(.*)Observer/, 1]
+          observed_class_name.constantize
+        else
+          nil
+        end
+      end
+    end
+
+    # Start observing the declared classes and their subclasses.
+    def initialize
+      observed_classes.each { |klass| add_observer!(klass) }
+    end
+
+    def observed_classes #:nodoc:
+      self.class.observed_classes
+    end
+
+    # Send observed_method(object) if the method exists.
+    def update(observed_method, object) #:nodoc:
+      send(observed_method, object) if respond_to?(observed_method)
+    end
+
+    # Special method sent by the observed class when it is inherited.
+    # Passes the new subclass.
+    def observed_class_inherited(subclass) #:nodoc:
+      self.class.observe(observed_classes + [subclass])
+      add_observer!(subclass)
+    end
+
+    protected
+      def add_observer!(klass) #:nodoc:
+        klass.add_observer(self)
+      end
+  end
+end

data/lib/active_model/railtie.rb

@@ -0,0 +1,2 @@
+require "active_model"
+require "rails"

data/lib/active_model/serialization.rb

@@ -0,0 +1,87 @@
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/hash/slice'
+
+module ActiveModel
+  # Provides a basic serialization to a serializable_hash for your object.
+  # 
+  # A minimal implementation could be:
+  #   
+  #   class Person
+  #   
+  #     include ActiveModel::Serialization
+  #   
+  #     attr_accessor :name
+  #   
+  #     def attributes
+  #       @attributes ||= {'name' => 'nil'}
+  #     end
+  #   
+  #   end
+  # 
+  # Which would provide you with:
+  # 
+  #   person = Person.new
+  #   person.serializable_hash   # => {"name"=>nil}
+  #   person.name = "Bob"
+  #   person.serializable_hash   # => {"name"=>"Bob"}
+  #
+  # You need to declare some sort of attributes hash which contains the attributes
+  # you want to serialize and their current value.
+  # 
+  # Most of the time though, you will want to include the JSON or XML 
+  # serializations.  Both of these modules automatically include the 
+  # ActiveModel::Serialization module, so there is no need to explicitly
+  # include it.
+  # 
+  # So a minimal implementation including XML and JSON would be:
+  #   
+  #   class Person
+  #   
+  #     include ActiveModel::Serializers::JSON
+  #     include ActiveModel::Serializers::Xml
+  #   
+  #     attr_accessor :name
+  #   
+  #     def attributes
+  #       @attributes ||= {'name' => 'nil'}
+  #     end
+  #   
+  #   end
+  # 
+  # Which would provide you with:
+  # 
+  #   person = Person.new
+  #   person.serializable_hash   # => {"name"=>nil}
+  #   person.to_json             # => "{\"name\":null}"
+  #   person.to_xml              # => "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<serial-person...
+  # 
+  #   person.name = "Bob"
+  #   person.serializable_hash   # => {"name"=>"Bob"}
+  #   person.to_json             # => "{\"name\":\"Bob\"}"
+  #   person.to_xml              # => "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<serial-person...
+  module Serialization
+    def serializable_hash(options = nil)
+      options ||= {}
+
+      options[:only]   = Array.wrap(options[:only]).map { |n| n.to_s }
+      options[:except] = Array.wrap(options[:except]).map { |n| n.to_s }
+
+      attribute_names = attributes.keys.sort
+      if options[:only].any?
+        attribute_names &= options[:only]
+      elsif options[:except].any?
+        attribute_names -= options[:except]
+      end
+
+      method_names = Array.wrap(options[:methods]).inject([]) do |methods, name|
+        methods << name if respond_to?(name.to_s)
+        methods
+      end
+
+      (attribute_names + method_names).inject({}) { |hash, name|
+        hash[name] = send(name)
+        hash
+      }
+    end
+  end
+end