backbone-forms-on-rails 0.10.0 → 0.10.0.1

data/vendor/bundle/gems/activemodel-3.2.11/lib/active_model/naming.rb

@@ -1,171 +0,0 @@
-require 'active_support/inflector'
-require 'active_support/core_ext/hash/except'
-require 'active_support/core_ext/module/introspection'
-require 'active_support/deprecation'
-
-module ActiveModel
-  class Name < String
-    attr_reader :singular, :plural, :element, :collection, :partial_path,
-      :singular_route_key, :route_key, :param_key, :i18n_key
-
-    alias_method :cache_key, :collection
-
-    deprecate :partial_path => "ActiveModel::Name#partial_path is deprecated. Call #to_partial_path on model instances directly instead."
-
-    def initialize(klass, namespace = nil, name = nil)
-      name ||= klass.name
-
-      raise ArgumentError, "Class name cannot be blank. You need to supply a name argument when anonymous class given" if name.blank?
-
-      super(name)
-
-      @unnamespaced = self.sub(/^#{namespace.name}::/, '') if namespace
-      @klass        = klass
-      @singular     = _singularize(self).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
-      @param_key    = (namespace ? _singularize(@unnamespaced) : @singular).freeze
-      @i18n_key     = self.underscore.to_sym
-
-      @route_key          = (namespace ? ActiveSupport::Inflector.pluralize(@param_key) : @plural.dup)
-      @singular_route_key = ActiveSupport::Inflector.singularize(@route_key).freeze
-      @route_key << "_index" if @plural == @singular
-      @route_key.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.i18n_key
-      end
-
-      defaults << options[:default] if options[:default]
-      defaults << @human
-
-      options = {:scope => [@klass.i18n_scope, :models], :count => 1, :default => defaults}.merge(options.except(:default))
-      I18n.translate(defaults.shift, options)
-    end
-
-    private
-
-    def _singularize(string, replacement='_')
-      ActiveSupport::Inflector.underscore(string).tr('/', replacement)
-    end
-  end
-
-  # == Active Model Naming
-  #
-  # Creates a +model_name+ method on your object.
-  #
-  # To implement, just extend ActiveModel::Naming in your object:
-  #
-  #   class BookCover
-  #     extend ActiveModel::Naming
-  #   end
-  #
-  #   BookCover.model_name        # => "BookCover"
-  #   BookCover.model_name.human  # => "Book cover"
-  #
-  #   BookCover.model_name.i18n_key              # => :book_cover
-  #   BookModule::BookCover.model_name.i18n_key  # => :"book_module/book_cover"
-  #
-  # Providing the functionality that ActiveModel::Naming provides in your object
-  # is required to pass the Active Model 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 ||= begin
-        namespace = self.parents.detect do |n|
-          n.respond_to?(:use_relative_model_naming?) && n.use_relative_model_naming?
-        end
-        ActiveModel::Name.new(self, namespace)
-      end
-    end
-
-    # Returns the plural class name of a record or class. Examples:
-    #
-    #   ActiveModel::Naming.plural(post)             # => "posts"
-    #   ActiveModel::Naming.plural(Highrise::Person) # => "highrise_people"
-    def self.plural(record_or_class)
-      model_name_from_record_or_class(record_or_class).plural
-    end
-
-    # Returns the singular class name of a record or class. Examples:
-    #
-    #   ActiveModel::Naming.singular(post)             # => "post"
-    #   ActiveModel::Naming.singular(Highrise::Person) # => "highrise_person"
-    def self.singular(record_or_class)
-      model_name_from_record_or_class(record_or_class).singular
-    end
-
-    # Identifies whether the class name of a record or class is uncountable. Examples:
-    #
-    #   ActiveModel::Naming.uncountable?(Sheep) # => true
-    #   ActiveModel::Naming.uncountable?(Post) => false
-    def self.uncountable?(record_or_class)
-      plural(record_or_class) == singular(record_or_class)
-    end
-
-    # Returns string to use while generating route names. It differs for
-    # namespaced models regarding whether it's inside isolated engine.
-    #
-    # For isolated engine:
-    # ActiveModel::Naming.route_key(Blog::Post) #=> post
-    #
-    # For shared engine:
-    # ActiveModel::Naming.route_key(Blog::Post) #=> blog_post
-    def self.singular_route_key(record_or_class)
-      model_name_from_record_or_class(record_or_class).singular_route_key
-    end
-
-    # Returns string to use while generating route names. It differs for
-    # namespaced models regarding whether it's inside isolated engine.
-    #
-    # For isolated engine:
-    # ActiveModel::Naming.route_key(Blog::Post) #=> posts
-    #
-    # For shared engine:
-    # ActiveModel::Naming.route_key(Blog::Post) #=> blog_posts
-    #
-    # The route key also considers if the noun is uncountable and, in
-    # such cases, automatically appends _index.
-    def self.route_key(record_or_class)
-      model_name_from_record_or_class(record_or_class).route_key
-    end
-
-    # Returns string to use for params names. It differs for
-    # namespaced models regarding whether it's inside isolated engine.
-    #
-    # For isolated engine:
-    # ActiveModel::Naming.param_key(Blog::Post) #=> post
-    #
-    # For shared engine:
-    # ActiveModel::Naming.param_key(Blog::Post) #=> blog_post
-    def self.param_key(record_or_class)
-      model_name_from_record_or_class(record_or_class).param_key
-    end
-
-    private
-      def self.model_name_from_record_or_class(record_or_class)
-        (record_or_class.is_a?(Class) ? record_or_class : convert_to_model(record_or_class).class).model_name
-      end
-
-      def self.convert_to_model(object)
-        object.respond_to?(:to_model) ? object.to_model : object
-      end
-  end
-
-end

data/vendor/bundle/gems/activemodel-3.2.11/lib/active_model/observer_array.rb

@@ -1,147 +0,0 @@
-require 'set'
-
-module ActiveModel
-  # Stores the enabled/disabled state of individual observers for
-  # a particular model class.
-  class ObserverArray < Array
-    attr_reader :model_class
-    def initialize(model_class, *args)
-      @model_class = model_class
-      super(*args)
-    end
-
-    # Returns true if the given observer is disabled for the model class.
-    def disabled_for?(observer)
-      disabled_observers.include?(observer.class)
-    end
-
-    # Disables one or more observers. This supports multiple forms:
-    #
-    #   ORM.observers.disable :user_observer
-    #     # => disables the UserObserver
-    #
-    #   User.observers.disable AuditTrail
-    #     # => disables the AuditTrail observer for User notifications.
-    #     #    Other models will still notify the AuditTrail observer.
-    #
-    #   ORM.observers.disable :observer_1, :observer_2
-    #     # => disables Observer1 and Observer2 for all models.
-    #
-    #   ORM.observers.disable :all
-    #     # => disables all observers for all models.
-    #
-    #   User.observers.disable :all do
-    #     # all user observers are disabled for
-    #     # just the duration of the block
-    #   end
-    def disable(*observers, &block)
-      set_enablement(false, observers, &block)
-    end
-
-    # Enables one or more observers. This supports multiple forms:
-    #
-    #   ORM.observers.enable :user_observer
-    #     # => enables the UserObserver
-    #
-    #   User.observers.enable AuditTrail
-    #     # => enables the AuditTrail observer for User notifications.
-    #     #    Other models will not be affected (i.e. they will not
-    #     #    trigger notifications to AuditTrail if previously disabled)
-    #
-    #   ORM.observers.enable :observer_1, :observer_2
-    #     # => enables Observer1 and Observer2 for all models.
-    #
-    #   ORM.observers.enable :all
-    #     # => enables all observers for all models.
-    #
-    #   User.observers.enable :all do
-    #     # all user observers are enabled for
-    #     # just the duration of the block
-    #   end
-    #
-    # Note: all observers are enabled by default. This method is only
-    # useful when you have previously disabled one or more observers.
-    def enable(*observers, &block)
-      set_enablement(true, observers, &block)
-    end
-
-    protected
-
-      def disabled_observers
-        @disabled_observers ||= Set.new
-      end
-
-      def observer_class_for(observer)
-        return observer if observer.is_a?(Class)
-
-        if observer.respond_to?(:to_sym) # string/symbol
-          observer.to_s.camelize.constantize
-        else
-          raise ArgumentError, "#{observer} was not a class or a " +
-            "lowercase, underscored class name as expected."
-        end
-      end
-
-      def start_transaction
-        disabled_observer_stack.push(disabled_observers.dup)
-        each_subclass_array do |array|
-          array.start_transaction
-        end
-      end
-
-      def disabled_observer_stack
-        @disabled_observer_stack ||= []
-      end
-
-      def end_transaction
-        @disabled_observers = disabled_observer_stack.pop
-        each_subclass_array do |array|
-          array.end_transaction
-        end
-      end
-
-      def transaction
-        start_transaction
-
-        begin
-          yield
-        ensure
-          end_transaction
-        end
-      end
-
-      def each_subclass_array
-        model_class.descendants.each do |subclass|
-          yield subclass.observers
-        end
-      end
-
-      def set_enablement(enabled, observers)
-        if block_given?
-          transaction do
-            set_enablement(enabled, observers)
-            yield
-          end
-        else
-          observers = ActiveModel::Observer.descendants if observers == [:all]
-          observers.each do |obs|
-            klass = observer_class_for(obs)
-
-            unless klass < ActiveModel::Observer
-              raise ArgumentError.new("#{obs} does not refer to a valid observer")
-            end
-
-            if enabled
-              disabled_observers.delete(klass)
-            else
-              disabled_observers << klass
-            end
-          end
-
-          each_subclass_array do |array|
-            array.set_enablement(enabled, observers)
-          end
-        end
-      end
-  end
-end

data/vendor/bundle/gems/activemodel-3.2.11/lib/active_model/observing.rb

@@ -1,252 +0,0 @@
-require 'singleton'
-require 'active_model/observer_array'
-require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/module/aliasing'
-require 'active_support/core_ext/module/remove_method'
-require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/enumerable'
-require 'active_support/descendants_tracker'
-
-module ActiveModel
-  module Observing
-    extend ActiveSupport::Concern
-
-    included do
-      extend ActiveSupport::DescendantsTracker
-    end
-
-    module ClassMethods
-      # == Active Model Observers Activation
-      #
-      # Activates the observers assigned. Examples:
-      #
-      #   class ORM
-      #     include ActiveModel::Observing
-      #   end
-      #
-      #   # Calls PersonObserver.instance
-      #   ORM.observers = :person_observer
-      #
-      #   # Calls Cacher.instance and GarbageCollector.instance
-      #   ORM.observers = :cacher, :garbage_collector
-      #
-      #   # Same as above, just using explicit class references
-      #   ORM.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.replace(values.flatten)
-      end
-
-      # Gets an array of observers observing this model.
-      # The array also provides +enable+ and +disable+ methods
-      # that allow you to selectively enable and disable observers.
-      # (see <tt>ActiveModel::ObserverArray.enable</tt> and
-      # <tt>ActiveModel::ObserverArray.disable</tt> for more on this)
-      def observers
-        @observers ||= ObserverArray.new(self)
-      end
-
-      # Gets the current observer instances.
-      def observer_instances
-        @observer_instances ||= []
-      end
-
-      # Instantiate the global observers.
-      def instantiate_observers
-        observers.each { |o| instantiate_observer(o) }
-      end
-
-      # Add a new observer to the pool.
-      # The new observer needs to respond to 'update', otherwise it
-      # raises an +ArgumentError+ exception.
-      def add_observer(observer)
-        unless observer.respond_to? :update
-          raise ArgumentError, "observer needs to respond to `update'"
-        end
-        observer_instances << observer
-      end
-
-      # Notify list of observers of a change.
-      def notify_observers(*arg)
-        observer_instances.each { |observer| observer.update(*arg) }
-      end
-
-      # Total number of observers.
-      def count_observers
-        observer_instances.size
-      end
-
-      protected
-        def instantiate_observer(observer) #:nodoc:
-          # string/symbol
-          if observer.respond_to?(:to_sym)
-            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
-          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.notify_observers(method, self)
-      end
-  end
-
-  # == Active Model Observers
-  #
-  # Observer classes respond to life cycle 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.comment("admin@do.com", "New comment was posted", comment).deliver
-  #     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 <tt>Observer.observe</tt>
-  # 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.
-  #
-  # If you're using an Observer in a Rails application with Active Record, be sure to
-  # read about the necessary configuration in the documentation for
-  # ActiveRecord::Observer.
-  #
-  class Observer
-    include Singleton
-    extend ActiveSupport::DescendantsTracker
-
-    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 }
-        redefine_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 and
-    # the observer is enabled for the given object's class.
-    def update(observed_method, object, &block) #:nodoc:
-      return unless respond_to?(observed_method)
-      return if disabled_for?(object)
-      send(observed_method, object, &block)
-    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
-
-      def disabled_for?(object)
-        klass = object.class
-        return false unless klass.respond_to?(:observers)
-        klass.observers.disabled_for?(self)
-      end
-  end
-end