backbone-queryparams-rails 0.0.1 → 0.0.2

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

@@ -1,134 +0,0 @@
-require 'active_support/core_ext/array/wrap'
-require 'active_support/callbacks'
-
-module ActiveModel
-  # == Active Model Callbacks
-  #
-  # Provides an interface for any class to have Active Record like callbacks.
-  #
-  # Like the Active Record methods, the callback chain is aborted as soon as
-  # one of the methods in the chain returns false.
-  #
-  # First, extend ActiveModel::Callbacks from the class you are creating:
-  #
-  #   class MyModel
-  #     extend ActiveModel::Callbacks
-  #   end
-  #
-  # Then define a list of methods that you want callbacks attached to:
-  #
-  #   define_model_callbacks :create, :update
-  #
-  # This will provide all three standard callbacks (before, around and after) for
-  # both the :create and :update methods. To implement, you need to wrap the methods
-  # you want callbacks on in a block so that the callbacks get a chance to fire:
-  #
-  #   def create
-  #     run_callbacks :create do
-  #       # Your create action methods here
-  #     end
-  #   end
-  #
-  # Then in your class, you can use the +before_create+, +after_create+ and +around_create+
-  # methods, just as you would in an Active Record module.
-  #
-  #   before_create :action_before_create
-  #
-  #   def action_before_create
-  #     # Your code here
-  #   end
-  #
-  # You can choose not to have all three callbacks by passing a hash to the
-  # define_model_callbacks method.
-  #
-  #   define_model_callbacks :create, :only => [:after, :before]
-  #
-  # Would only create the after_create and before_create callback methods in your
-  # class.
-  module Callbacks
-    def self.extended(base)
-      base.class_eval do
-        include ActiveSupport::Callbacks
-      end
-    end
-
-    # define_model_callbacks accepts the same options define_callbacks does, in case
-    # you want to overwrite a default. Besides that, it also accepts an :only option,
-    # where you can choose if you want all types (before, around or after) or just some.
-    #
-    #   define_model_callbacks :initializer, :only => :after
-    #
-    # Note, the <tt>:only => <type></tt> hash will apply to all callbacks defined on
-    # that method call. To get around this you can call the define_model_callbacks
-    # method as many times as you need.
-    #
-    #   define_model_callbacks :create, :only => :after
-    #   define_model_callbacks :update, :only => :before
-    #   define_model_callbacks :destroy, :only => :around
-    #
-    # Would create +after_create+, +before_update+ and +around_destroy+ methods only.
-    #
-    # You can pass in a class to before_<type>, after_<type> and around_<type>, in which
-    # case the callback will call that class's <action>_<type> method passing the object
-    # that the callback is being called on.
-    #
-    #   class MyModel
-    #     extend ActiveModel::Callbacks
-    #     define_model_callbacks :create
-    #
-    #     before_create AnotherClass
-    #   end
-    #
-    #   class AnotherClass
-    #     def self.before_create( obj )
-    #       # obj is the MyModel instance that the callback is being called on
-    #     end
-    #   end
-    #
-    def define_model_callbacks(*callbacks)
-      options = callbacks.extract_options!
-      options = {
-         :terminator => "result == false",
-         :scope => [:kind, :name],
-         :only => [:before, :around, :after]
-      }.merge(options)
-
-      types = Array.wrap(options.delete(:only))
-
-      callbacks.each do |callback|
-        define_callbacks(callback, options)
-
-        types.each do |type|
-          send("_define_#{type}_model_callback", self, callback)
-        end
-      end
-    end
-
-    def _define_before_model_callback(klass, callback) #:nodoc:
-      klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
-        def self.before_#{callback}(*args, &block)
-          set_callback(:#{callback}, :before, *args, &block)
-        end
-      CALLBACK
-    end
-
-    def _define_around_model_callback(klass, callback) #:nodoc:
-      klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
-        def self.around_#{callback}(*args, &block)
-          set_callback(:#{callback}, :around, *args, &block)
-        end
-      CALLBACK
-    end
-
-    def _define_after_model_callback(klass, callback) #:nodoc:
-      klass.class_eval <<-CALLBACK, __FILE__, __LINE__ + 1
-        def self.after_#{callback}(*args, &block)
-          options = args.extract_options!
-          options[:prepend] = true
-          options[:if] = Array.wrap(options[:if]) << "!halted && value != false"
-          set_callback(:#{callback}, :after, *(args << options), &block)
-        end
-      CALLBACK
-    end
-  end
-end

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

@@ -1,73 +0,0 @@
-require 'active_support/concern'
-require 'active_support/inflector'
-
-module ActiveModel
-  # == Active Model Conversions
-  #
-  # Handles default conversions: to_model, to_key, to_param, and to_partial_path.
-  #
-  # 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
-  #
-  #   cm = ContactMessage.new
-  #   cm.to_model == self # => true
-  #   cm.to_key           # => nil
-  #   cm.to_param         # => nil
-  #   cm.to_path          # => "contact_messages/contact_message"
-  #
-  module Conversion
-    extend ActiveSupport::Concern
-
-    # If your object is already designed to implement all of the Active Model
-    # you can use the default <tt>:to_model</tt> 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 key attributes if any is set, regardless
-    # if the object is persisted or not.
-    #
-    # Note the default implementation uses persisted? just because all objects
-    # in Ruby 1.8.x responds to <tt>:id</tt>.
-    def to_key
-      persisted? ? [id] : nil
-    end
-
-    # Returns a string representing the object's key suitable for use in URLs,
-    # or nil if <tt>persisted?</tt> is false.
-    def to_param
-      persisted? ? to_key.join('-') : nil
-    end
-
-    # Returns a string identifying the path associated with the object.
-    # ActionPack uses this to find a suitable partial to represent the object.
-    def to_partial_path
-      self.class._to_partial_path
-    end
-
-    module ClassMethods #:nodoc:
-      # Provide a class level cache for the to_path. This is an
-      # internal method and should not be accessed directly.
-      def _to_partial_path #:nodoc:
-        @_to_partial_path ||= begin
-          element = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(self))
-          collection = ActiveSupport::Inflector.tableize(self)
-          "#{collection}/#{element}".freeze
-        end
-      end
-    end
-  end
-end

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

@@ -1,167 +0,0 @@
-require 'active_model/attribute_methods'
-require 'active_support/hash_with_indifferent_access'
-require 'active_support/core_ext/object/duplicable'
-
-module ActiveModel
-  # == Active Model Dirty
-  #
-  # Provides a way to track changes in your object in the same way as
-  # Active Record does.
-  #
-  # The requirements for implementing ActiveModel::Dirty are:
-  #
-  # * <tt>include ActiveModel::Dirty</tt> in your object
-  # * Call <tt>define_attribute_methods</tt> passing each method you want to
-  #   track
-  # * Call <tt>attr_name_will_change!</tt> before each change to the tracked
-  #   attribute
-  #
-  # If you wish to also track previous changes on save or update, you need to
-  # add
-  #
-  #   @previously_changed = changes
-  #
-  # inside of your save or update method.
-  #
-  # A minimal implementation could be:
-  #
-  #   class Person
-  #
-  #     include ActiveModel::Dirty
-  #
-  #     define_attribute_methods [:name]
-  #
-  #     def name
-  #       @name
-  #     end
-  #
-  #     def name=(val)
-  #       name_will_change! unless val == @name
-  #       @name = val
-  #     end
-  #
-  #     def save
-  #       @previously_changed = changes
-  #       @changed_attributes.clear
-  #     end
-  #
-  #   end
-  #
-  # == Examples:
-  #
-  # A newly instantiated object is unchanged:
-  #   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 = 'Bill'
-  #   person.name_change    # => ['Uncle Bob', 'Bill']
-  #
-  # Save the changes:
-  #   person.save
-  #   person.changed?       # => false
-  #   person.name_changed?  # => false
-  #
-  # Assigning the same value leaves the attribute unchanged:
-  #   person.name = 'Bill'
-  #   person.name_changed?  # => false
-  #   person.name_change    # => nil
-  #
-  # Which attributes have changed?
-  #   person.name = 'Bob'
-  #   person.changed        # => ['name']
-  #   person.changes        # => { 'name' => ['Bill', 'Bob'] }
-  #
-  # If an attribute is modified in-place then make use of <tt>[attribute_name]_will_change!</tt>
-  # to mark that the attribute is changing. Otherwise ActiveModel can't track changes to
-  # in-place attributes.
-  #
-  #   person.name_will_change!
-  #   person.name << 'y'
-  #   person.name_change    # => ['Bill', 'Billy']
-  module Dirty
-    extend ActiveSupport::Concern
-    include ActiveModel::AttributeMethods
-
-    included do
-      attribute_method_suffix '_changed?', '_change', '_will_change!', '_was'
-      attribute_method_affix :prefix => 'reset_', :suffix => '!'
-    end
-
-    # Returns true if any attribute have unsaved changes, false otherwise.
-    #   person.changed? # => false
-    #   person.name = 'bob'
-    #   person.changed? # => true
-    def changed?
-      changed_attributes.any?
-    end
-
-    # List of attributes with unsaved changes.
-    #   person.changed # => []
-    #   person.name = 'bob'
-    #   person.changed # => ['name']
-    def changed
-      changed_attributes.keys
-    end
-
-    # Map of changed attrs => [original value, new value].
-    #   person.changes # => {}
-    #   person.name = 'bob'
-    #   person.changes # => { 'name' => ['bill', 'bob'] }
-    def changes
-      HashWithIndifferentAccess[changed.map { |attr| [attr, attribute_change(attr)] }]
-    end
-
-    # Map of attributes that were changed when the model was saved.
-    #   person.name # => 'bob'
-    #   person.name = 'robert'
-    #   person.save
-    #   person.previous_changes # => {'name' => ['bob, 'robert']}
-    def previous_changes
-      @previously_changed
-    end
-
-    # Map of change <tt>attr => original value</tt>.
-    def changed_attributes
-      @changed_attributes ||= {}
-    end
-
-    private
-
-      # Handle <tt>*_changed?</tt> for +method_missing+.
-      def attribute_changed?(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)
-      end
-
-      # Handle <tt>*_was</tt> for +method_missing+.
-      def attribute_was(attr)
-        attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
-      end
-
-      # Handle <tt>*_will_change!</tt> for +method_missing+.
-      def attribute_will_change!(attr)
-        begin
-          value = __send__(attr)
-          value = value.duplicable? ? value.clone : value
-        rescue TypeError, NoMethodError
-        end
-
-        changed_attributes[attr] = value unless changed_attributes.include?(attr)
-      end
-
-      # Handle <tt>reset_*!</tt> for +method_missing+.
-      def reset_attribute!(attr)
-        __send__("#{attr}=", changed_attributes[attr]) if attribute_changed?(attr)
-      end
-  end
-end

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

@@ -1,370 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require 'active_support/core_ext/array/wrap'
-require 'active_support/core_ext/array/conversions'
-require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/hash/reverse_merge'
-require 'active_support/ordered_hash'
-
-module ActiveModel
-  # == Active Model Errors
-  #
-  # Provides a modified +OrderedHash+ that you can include in your object
-  # for handling error messages and interacting with Action Pack helpers.
-  #
-  # A minimal implementation could be:
-  #
-  #   class Person
-  #
-  #     # Required dependency for ActiveModel::Errors
-  #     extend ActiveModel::Naming
-  #
-  #     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
-  #
-  #     # The following methods are needed to be minimally implemented
-  #
-  #     def read_attribute_for_validation(attr)
-  #       send(attr)
-  #     end
-  #
-  #     def Person.human_attribute_name(attr, options = {})
-  #       attr
-  #     end
-  #
-  #     def Person.lookup_ancestors
-  #       [self]
-  #     end
-  #
-  #   end
-  #
-  # The last three methods are required in your object for Errors to be
-  # able to generate error messages correctly and also handle multiple
-  # languages. Of course, if you extend your object with ActiveModel::Translation
-  # you will not need to implement the last two. Likewise, using
-  # ActiveModel::Validations will handle the validation related methods
-  # for you.
-  #
-  # The above allows you to do:
-  #
-  #   p = Person.new
-  #   p.validate!             # => ["can not be nil"]
-  #   p.errors.full_messages  # => ["name can not be nil"]
-  #   # etc..
-  class Errors
-    include Enumerable
-
-    CALLBACKS_OPTIONS = [:if, :unless, :on, :allow_nil, :allow_blank, :strict]
-
-    attr_reader :messages
-
-    # Pass in the instance of the object that is using the errors object.
-    #
-    #   class Person
-    #     def initialize
-    #       @errors = ActiveModel::Errors.new(self)
-    #     end
-    #   end
-    def initialize(base)
-      @base     = base
-      @messages = ActiveSupport::OrderedHash.new
-    end
-
-    def initialize_dup(other)
-      @messages = other.messages.dup
-    end
-
-    # Backport dup from 1.9 so that #initialize_dup gets called
-    unless Object.respond_to?(:initialize_dup)
-      def dup # :nodoc:
-        copy = super
-        copy.initialize_dup(self)
-        copy
-      end
-    end
-
-    # Clear the messages
-    def clear
-      messages.clear
-    end
-
-    # Do the error messages include an error with key +error+?
-    def include?(error)
-      (v = messages[error]) && v.any?
-    end
-    alias :has_key? :include?
-
-    # Get messages for +key+
-    def get(key)
-      messages[key]
-    end
-
-    # Set messages for +key+ to +value+
-    def set(key, value)
-      messages[key] = value
-    end
-
-    # Delete messages for +key+
-    def delete(key)
-      messages.delete(key)
-    end
-
-    # When passed a symbol or a name of a method, returns an array of errors
-    # for the method.
-    #
-    #   p.errors[:name]   # => ["can not be nil"]
-    #   p.errors['name']  # => ["can not be nil"]
-    def [](attribute)
-      get(attribute.to_sym) || set(attribute.to_sym, [])
-    end
-
-    # Adds to the supplied attribute the supplied error message.
-    #
-    #   p.errors[:name] = "must be set"
-    #   p.errors[:name] # => ['must be set']
-    def []=(attribute, error)
-      self[attribute] << error
-    end
-
-    # Iterates through each error key, value pair in the error messages hash.
-    # Yields the attribute and the error for that attribute. If the attribute
-    # has more than one error message, yields once for each error message.
-    #
-    #   p.errors.add(:name, "can't be blank")
-    #   p.errors.each do |attribute, errors_array|
-    #     # Will yield :name and "can't be blank"
-    #   end
-    #
-    #   p.errors.add(:name, "must be specified")
-    #   p.errors.each do |attribute, errors_array|
-    #     # Will yield :name and "can't be blank"
-    #     # then yield :name and "must be specified"
-    #   end
-    def each
-      messages.each_key do |attribute|
-        self[attribute].each { |error| yield attribute, error }
-      end
-    end
-
-    # Returns the number of error messages.
-    #
-    #   p.errors.add(:name, "can't be blank")
-    #   p.errors.size # => 1
-    #   p.errors.add(:name, "must be specified")
-    #   p.errors.size # => 2
-    def size
-      values.flatten.size
-    end
-
-    # Returns all message values
-    def values
-      messages.values
-    end
-
-    # Returns all message keys
-    def keys
-      messages.keys
-    end
-
-    # Returns an array of error messages, with the attribute name included
-    #
-    #   p.errors.add(:name, "can't be blank")
-    #   p.errors.add(:name, "must be specified")
-    #   p.errors.to_a # => ["name can't be blank", "name must be specified"]
-    def to_a
-      full_messages
-    end
-
-    # Returns the number of error messages.
-    #   p.errors.add(:name, "can't be blank")
-    #   p.errors.count # => 1
-    #   p.errors.add(:name, "must be specified")
-    #   p.errors.count # => 2
-    def count
-      to_a.size
-    end
-
-    # Returns true if no errors are found, false otherwise.
-    # If the error message is a string it can be empty.
-    def empty?
-      all? { |k, v| v && v.empty? && !v.is_a?(String) }
-    end
-    alias_method :blank?, :empty?
-
-    # Returns an xml formatted representation of the Errors hash.
-    #
-    #   p.errors.add(:name, "can't be blank")
-    #   p.errors.add(:name, "must be specified")
-    #   p.errors.to_xml
-    #   # =>
-    #   #  <?xml version=\"1.0\" encoding=\"UTF-8\"?>
-    #   #  <errors>
-    #   #    <error>name can't be blank</error>
-    #   #    <error>name must be specified</error>
-    #   #  </errors>
-    def to_xml(options={})
-      to_a.to_xml options.reverse_merge(:root => "errors", :skip_types => true)
-    end
-
-    # Returns an ActiveSupport::OrderedHash that can be used as the JSON representation for this object.
-    def as_json(options=nil)
-      to_hash
-    end
-
-    def to_hash
-      messages.dup
-    end
-
-    # Adds +message+ to the error messages on +attribute+. More than one error can be added to the same
-    # +attribute+.
-    # If no +message+ is supplied, <tt>:invalid</tt> is assumed.
-    #
-    # If +message+ is a symbol, it will be translated using the appropriate scope (see +translate_error+).
-    # If +message+ is a proc, it will be called, allowing for things like <tt>Time.now</tt> to be used within an error.
-    def add(attribute, message = nil, options = {})
-      message = normalize_message(attribute, message, options)
-      if options[:strict]
-        raise ActiveModel::StrictValidationFailed, full_message(attribute, message)
-      end
-
-      self[attribute] << message
-    end
-
-    # Will add an error message to each of the attributes in +attributes+ that is empty.
-    def add_on_empty(attributes, options = {})
-      [attributes].flatten.each do |attribute|
-        value = @base.send(:read_attribute_for_validation, attribute)
-        is_empty = value.respond_to?(:empty?) ? value.empty? : false
-        add(attribute, :empty, options) if value.nil? || is_empty
-      end
-    end
-
-    # Will add an error message to each of the attributes in +attributes+ that is blank (using Object#blank?).
-    def add_on_blank(attributes, options = {})
-      [attributes].flatten.each do |attribute|
-        value = @base.send(:read_attribute_for_validation, attribute)
-        add(attribute, :blank, options) if value.blank?
-      end
-    end
-
-    # Returns true if an error on the attribute with the given message is present, false otherwise.
-    # +message+ is treated the same as for +add+.
-    #   p.errors.add :name, :blank
-    #   p.errors.added? :name, :blank # => true
-    def added?(attribute, message = nil, options = {})
-      message = normalize_message(attribute, message, options)
-      self[attribute].include? message
-    end
-
-    # Returns all the full error messages in an array.
-    #
-    #   class Company
-    #     validates_presence_of :name, :address, :email
-    #     validates_length_of :name, :in => 5..30
-    #   end
-    #
-    #   company = Company.create(:address => '123 First St.')
-    #   company.errors.full_messages # =>
-    #     ["Name is too short (minimum is 5 characters)", "Name can't be blank", "Email can't be blank"]
-    def full_messages
-      map { |attribute, message| full_message(attribute, message) }
-    end
-
-    # Returns a full message for a given attribute.
-    #
-    #   company.errors.full_message(:name, "is invalid")  # =>
-    #     "Name is invalid"
-    def full_message(attribute, message)
-      return message if attribute == :base
-      attr_name = attribute.to_s.gsub('.', '_').humanize
-      attr_name = @base.class.human_attribute_name(attribute, :default => attr_name)
-      I18n.t(:"errors.format", {
-        :default   => "%{attribute} %{message}",
-        :attribute => attr_name,
-        :message   => message
-      })
-    end
-
-    # Translates an error message in its default scope
-    # (<tt>activemodel.errors.messages</tt>).
-    #
-    # Error messages are first looked up in <tt>models.MODEL.attributes.ATTRIBUTE.MESSAGE</tt>,
-    # if it's not there, it's looked up in <tt>models.MODEL.MESSAGE</tt> and if that is not
-    # there also, it returns the translation of the default message
-    # (e.g. <tt>activemodel.errors.messages.MESSAGE</tt>). The translated model name,
-    # translated attribute name and the value are available for interpolation.
-    #
-    # When using inheritance in your models, it will check all the inherited
-    # models too, but only if the model itself hasn't been found. Say you have
-    # <tt>class Admin < User; end</tt> and you wanted the translation for
-    # the <tt>:blank</tt> error message for the <tt>title</tt> attribute,
-    # it looks for these translations:
-    #
-    # * <tt>activemodel.errors.models.admin.attributes.title.blank</tt>
-    # * <tt>activemodel.errors.models.admin.blank</tt>
-    # * <tt>activemodel.errors.models.user.attributes.title.blank</tt>
-    # * <tt>activemodel.errors.models.user.blank</tt>
-    # * any default you provided through the +options+ hash (in the <tt>activemodel.errors</tt> scope)
-    # * <tt>activemodel.errors.messages.blank</tt>
-    # * <tt>errors.attributes.title.blank</tt>
-    # * <tt>errors.messages.blank</tt>
-    #
-    def generate_message(attribute, type = :invalid, options = {})
-      type = options.delete(:message) if options[:message].is_a?(Symbol)
-
-      if @base.class.respond_to?(:i18n_scope)
-        defaults = @base.class.lookup_ancestors.map do |klass|
-          [ :"#{@base.class.i18n_scope}.errors.models.#{klass.model_name.i18n_key}.attributes.#{attribute}.#{type}",
-            :"#{@base.class.i18n_scope}.errors.models.#{klass.model_name.i18n_key}.#{type}" ]
-        end
-      else
-        defaults = []
-      end
-
-      defaults << options.delete(:message)
-      defaults << :"#{@base.class.i18n_scope}.errors.messages.#{type}" if @base.class.respond_to?(:i18n_scope)
-      defaults << :"errors.attributes.#{attribute}.#{type}"
-      defaults << :"errors.messages.#{type}"
-
-      defaults.compact!
-      defaults.flatten!
-
-      key = defaults.shift
-      value = (attribute != :base ? @base.send(:read_attribute_for_validation, attribute) : nil)
-
-      options = {
-        :default => defaults,
-        :model => @base.class.model_name.human,
-        :attribute => @base.class.human_attribute_name(attribute),
-        :value => value
-      }.merge(options)
-
-      I18n.translate(key, options)
-    end
-
-  private
-    def normalize_message(attribute, message, options)
-      message ||= :invalid
-
-      if message.is_a?(Symbol)
-        generate_message(attribute, message, options.except(*CALLBACKS_OPTIONS))
-      elsif message.is_a?(Proc)
-        message.call
-      else
-        message
-      end
-    end
-  end
-
-  class StrictValidationFailed < StandardError
-  end
-end