backbone-queryparams-rails 0.0.1 → 0.0.2

data/vendor/bundle/gems/actionpack-3.2.11/lib/abstract_controller/logger.rb

@@ -1,13 +0,0 @@
-require "active_support/core_ext/logger"
-require "active_support/benchmarkable"
-
-module AbstractController
-  module Logger
-    extend ActiveSupport::Concern
-
-    included do
-      config_accessor :logger
-      include ActiveSupport::Benchmarkable
-    end
-  end
-end

data/vendor/bundle/gems/actionpack-3.2.11/lib/abstract_controller/railties/routes_helpers.rb

@@ -1,18 +0,0 @@
-module AbstractController
-  module Railties
-    module RoutesHelpers
-      def self.with(routes)
-        Module.new do
-          define_method(:inherited) do |klass|
-            super(klass)
-            if namespace = klass.parents.detect { |m| m.respond_to?(:railtie_routes_url_helpers) }
-              klass.send(:include, namespace.railtie_routes_url_helpers)
-            else
-              klass.send(:include, routes.url_helpers)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/gems/actionpack-3.2.11/lib/abstract_controller/rendering.rb

@@ -1,179 +0,0 @@
-require "abstract_controller/base"
-require "action_view"
-require "active_support/core_ext/object/instance_variables"
-
-module AbstractController
-  class DoubleRenderError < Error
-    DEFAULT_MESSAGE = "Render and/or redirect were called multiple times in this action. Please note that you may only call render OR redirect, and at most once per action. Also note that neither redirect nor render terminate execution of the action, so if you want to exit an action after redirecting, you need to do something like \"redirect_to(...) and return\"."
-
-    def initialize(message = nil)
-      super(message || DEFAULT_MESSAGE)
-    end
-  end
-
-  # This is a class to fix I18n global state. Whenever you provide I18n.locale during a request,
-  # it will trigger the lookup_context and consequently expire the cache.
-  class I18nProxy < ::I18n::Config #:nodoc:
-    attr_reader :original_config, :lookup_context
-
-    def initialize(original_config, lookup_context)
-      original_config = original_config.original_config if original_config.respond_to?(:original_config)
-      @original_config, @lookup_context = original_config, lookup_context
-    end
-
-    def locale
-      @original_config.locale
-    end
-
-    def locale=(value)
-      @lookup_context.locale = value
-    end
-  end
-
-  module Rendering
-    extend ActiveSupport::Concern
-    include AbstractController::ViewPaths
-
-    included do
-      class_attribute :protected_instance_variables
-      self.protected_instance_variables = []
-    end
-
-    # Overwrite process to setup I18n proxy.
-    def process(*) #:nodoc:
-      old_config, I18n.config = I18n.config, I18nProxy.new(I18n.config, lookup_context)
-      super
-    ensure
-      I18n.config = old_config
-    end
-
-    module ClassMethods
-      def view_context_class
-        @view_context_class ||= begin
-          routes  = _routes  if respond_to?(:_routes)
-          helpers = _helpers if respond_to?(:_helpers)
-          ActionView::Base.prepare(routes, helpers)
-        end
-      end
-    end
-
-    attr_internal_writer :view_context_class
-
-    def view_context_class
-      @_view_context_class ||= self.class.view_context_class
-    end
-
-    # An instance of a view class. The default view class is ActionView::Base
-    #
-    # The view class must have the following methods:
-    # View.new[lookup_context, assigns, controller]
-    #   Create a new ActionView instance for a controller
-    # View#render[options]
-    #   Returns String with the rendered template
-    #
-    # Override this method in a module to change the default behavior.
-    def view_context
-      view_context_class.new(view_renderer, view_assigns, self)
-    end
-
-    # Returns an object that is able to render templates.
-    def view_renderer
-      @_view_renderer ||= ActionView::Renderer.new(lookup_context)
-    end
-
-    # Normalize arguments, options and then delegates render_to_body and
-    # sticks the result in self.response_body.
-    def render(*args, &block)
-      options = _normalize_render(*args, &block)
-      self.response_body = render_to_body(options)
-    end
-
-    # Raw rendering of a template to a string. Just convert the results of
-    # render_response into a String.
-    # :api: plugin
-    def render_to_string(*args, &block)
-      options = _normalize_render(*args, &block)
-      render_to_body(options)
-    end
-
-    # Raw rendering of a template to a Rack-compatible body.
-    # :api: plugin
-    def render_to_body(options = {})
-      _process_options(options)
-      _render_template(options)
-    end
-
-    # Find and renders a template based on the options given.
-    # :api: private
-    def _render_template(options) #:nodoc:
-      lookup_context.rendered_format = nil if options[:formats]
-      view_renderer.render(view_context, options)
-    end
-
-    DEFAULT_PROTECTED_INSTANCE_VARIABLES = %w(
-      @_action_name @_response_body @_formats @_prefixes @_config
-      @_view_context_class @_view_renderer @_lookup_context
-    )
-
-    # This method should return a hash with assigns.
-    # You can overwrite this configuration per controller.
-    # :api: public
-    def view_assigns
-      hash = {}
-      variables  = instance_variable_names
-      variables -= protected_instance_variables
-      variables -= DEFAULT_PROTECTED_INSTANCE_VARIABLES
-      variables.each { |name| hash[name.to_s[1, name.length]] = instance_variable_get(name) }
-      hash
-    end
-
-    private
-
-    # Normalize args and options.
-    # :api: private
-    def _normalize_render(*args, &block)
-      options = _normalize_args(*args, &block)
-      _normalize_options(options)
-      options
-    end
-
-    # Normalize args by converting render "foo" to render :action => "foo" and
-    # render "foo/bar" to render :file => "foo/bar".
-    # :api: plugin
-    def _normalize_args(action=nil, options={})
-      case action
-      when NilClass
-      when Hash
-        options = action
-      when String, Symbol
-        action = action.to_s
-        key = action.include?(?/) ? :file : :action
-        options[key] = action
-      else
-        options[:partial] = action
-      end
-
-      options
-    end
-
-    # Normalize options.
-    # :api: plugin
-    def _normalize_options(options)
-      if options[:partial] == true
-        options[:partial] = action_name
-      end
-
-      if (options.keys & [:partial, :file, :template]).empty?
-        options[:prefixes] ||= _prefixes
-      end
-
-      options[:template] ||= (options[:action] || action_name).to_s
-      options
-    end
-
-    # Process extra options.
-    # :api: plugin
-    def _process_options(options)
-    end
-  end
-end

data/vendor/bundle/gems/actionpack-3.2.11/lib/abstract_controller/translation.rb

@@ -1,13 +0,0 @@
-module AbstractController
-  module Translation
-    def translate(*args)
-      I18n.translate(*args)
-    end
-    alias :t :translate
-
-    def localize(*args)
-      I18n.localize(*args)
-    end
-    alias :l :localize
-  end
-end

data/vendor/bundle/gems/actionpack-3.2.11/lib/abstract_controller/url_for.rb

@@ -1,33 +0,0 @@
-# Includes +url_for+ into the host class (e.g. an abstract controller or mailer). The class
-# has to provide a +RouteSet+ by implementing the <tt>_routes</tt> methods. Otherwise, an
-# exception will be raised.
-#
-# Note that this module is completely decoupled from HTTP - the only requirement is a valid 
-# <tt>_routes</tt> implementation.
-module AbstractController
-  module UrlFor
-    extend ActiveSupport::Concern
-    include ActionDispatch::Routing::UrlFor
-
-    def _routes
-      raise "In order to use #url_for, you must include routing helpers explicitly. " \
-            "For instance, `include Rails.application.routes.url_helpers"
-    end
-
-    module ClassMethods
-      def _routes
-        nil
-      end
-
-      def action_methods
-        @action_methods ||= begin
-          if _routes
-            super - _routes.named_routes.helper_names
-          else
-            super
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/gems/actionpack-3.2.11/lib/abstract_controller/view_paths.rb

@@ -1,96 +0,0 @@
-require 'action_view/base'
-
-module AbstractController
-  module ViewPaths
-    extend ActiveSupport::Concern
-
-    included do
-      class_attribute :_view_paths
-      self._view_paths = ActionView::PathSet.new
-      self._view_paths.freeze
-    end
-
-    delegate :template_exists?, :view_paths, :formats, :formats=,
-             :locale, :locale=, :to => :lookup_context
-
-    module ClassMethods
-      def parent_prefixes
-        @parent_prefixes ||= begin
-          parent_controller = superclass
-          prefixes = []
-
-          until parent_controller.abstract?
-            prefixes << parent_controller.controller_path
-            parent_controller = parent_controller.superclass
-          end
-
-          prefixes
-        end
-      end
-    end
-
-    # The prefixes used in render "foo" shortcuts.
-    def _prefixes
-      @_prefixes ||= begin
-        parent_prefixes = self.class.parent_prefixes
-        parent_prefixes.dup.unshift(controller_path)
-      end
-    end
-
-    # LookupContext is the object responsible to hold all information required to lookup
-    # templates, i.e. view paths and details. Check ActionView::LookupContext for more
-    # information.
-    def lookup_context
-      @_lookup_context ||=
-        ActionView::LookupContext.new(self.class._view_paths, details_for_lookup, _prefixes)
-    end
-
-    def details_for_lookup
-      { }
-    end
-
-    def append_view_path(path)
-      lookup_context.view_paths.push(*path)
-    end
-
-    def prepend_view_path(path)
-      lookup_context.view_paths.unshift(*path)
-    end
-
-    module ClassMethods
-      # Append a path to the list of view paths for this controller.
-      #
-      # ==== Parameters
-      # * <tt>path</tt> - If a String is provided, it gets converted into
-      #   the default view path. You may also provide a custom view path
-      #   (see ActionView::PathSet for more information)
-      def append_view_path(path)
-        self._view_paths = view_paths + Array(path)
-      end
-
-      # Prepend a path to the list of view paths for this controller.
-      #
-      # ==== Parameters
-      # * <tt>path</tt> - If a String is provided, it gets converted into
-      #   the default view path. You may also provide a custom view path
-      #   (see ActionView::PathSet for more information)
-      def prepend_view_path(path)
-        self._view_paths = ActionView::PathSet.new(Array(path) + view_paths)
-      end
-
-      # A list of all of the default view paths for this controller.
-      def view_paths
-        _view_paths
-      end
-
-      # Set the view paths.
-      #
-      # ==== Parameters
-      # * <tt>paths</tt> - If a PathSet is provided, use that;
-      #   otherwise, process the parameter into a PathSet.
-      def view_paths=(paths)
-        self._view_paths = ActionView::PathSet.new(Array.wrap(paths))
-      end
-    end
-  end
-end

data/vendor/bundle/gems/actionpack-3.2.11/lib/action_controller.rb

@@ -1,65 +0,0 @@
-require 'abstract_controller'
-require 'action_dispatch'
-
-module ActionController
-  extend ActiveSupport::Autoload
-
-  autoload :Base
-  autoload :Caching
-  autoload :Metal
-  autoload :Middleware
-
-  autoload_under "metal" do
-    autoload :Compatibility
-    autoload :ConditionalGet
-    autoload :Cookies
-    autoload :DataStreaming
-    autoload :Flash
-    autoload :ForceSSL
-    autoload :Head
-    autoload :Helpers
-    autoload :HideActions
-    autoload :HttpAuthentication
-    autoload :ImplicitRender
-    autoload :Instrumentation
-    autoload :MimeResponds
-    autoload :ParamsWrapper
-    autoload :RackDelegation
-    autoload :Redirecting
-    autoload :Renderers
-    autoload :Rendering
-    autoload :RequestForgeryProtection
-    autoload :Rescue
-    autoload :Responder
-    autoload :SessionManagement
-    autoload :Streaming
-    autoload :Testing
-    autoload :UrlFor
-  end
-
-  autoload :Integration,        'action_controller/deprecated/integration_test'
-  autoload :IntegrationTest,    'action_controller/deprecated/integration_test'
-  autoload :PerformanceTest,    'action_controller/deprecated/performance_test'
-  autoload :UrlWriter,          'action_controller/deprecated'
-  autoload :Routing,            'action_controller/deprecated'
-  autoload :TestCase,           'action_controller/test_case'
-  autoload :TemplateAssertions, 'action_controller/test_case'
-
-  eager_autoload do
-    autoload :RecordIdentifier
-  end
-end
-
-# All of these simply register additional autoloads
-require 'action_view'
-require 'action_controller/vendor/html-scanner'
-
-# Common Active Support usage in Action Controller
-require 'active_support/concern'
-require 'active_support/core_ext/class/attribute_accessors'
-require 'active_support/core_ext/load_error'
-require 'active_support/core_ext/module/attr_internal'
-require 'active_support/core_ext/module/delegation'
-require 'active_support/core_ext/name_error'
-require 'active_support/core_ext/uri'
-require 'active_support/inflector'

data/vendor/bundle/gems/actionpack-3.2.11/lib/action_controller/base.rb

@@ -1,235 +0,0 @@
-require "action_controller/log_subscriber"
-
-module ActionController
-  # Action Controllers are the core of a web request in \Rails. They are made up of one or more actions that are executed
-  # on request and then either render a template or redirect to another action. An action is defined as a public method
-  # on the controller, which will automatically be made accessible to the web-server through \Rails Routes.
-  #
-  # By default, only the ApplicationController in a \Rails application inherits from <tt>ActionController::Base</tt>. All other
-  # controllers in turn inherit from ApplicationController. This gives you one class to configure things such as
-  # request forgery protection and filtering of sensitive request parameters.
-  #
-  # A sample controller could look like this:
-  #
-  #   class PostsController < ApplicationController
-  #     def index
-  #       @posts = Post.all
-  #     end
-  #
-  #     def create
-  #       @post = Post.create params[:post]
-  #       redirect_to posts_path
-  #     end
-  #   end
-  #
-  # Actions, by default, render a template in the <tt>app/views</tt> directory corresponding to the name of the controller and action
-  # after executing code in the action. For example, the +index+ action of the PostsController would render the
-  # template <tt>app/views/posts/index.html.erb</tt> by default after populating the <tt>@posts</tt> instance variable.
-  #
-  # Unlike index, the create action will not render a template. After performing its main purpose (creating a
-  # new post), it initiates a redirect instead. This redirect works by returning an external
-  # "302 Moved" HTTP response that takes the user to the index action.
-  #
-  # These two methods represent the two basic action archetypes used in Action Controllers. Get-and-show and do-and-redirect.
-  # Most actions are variations on these themes.
-  #
-  # == Requests
-  #
-  # For every request, the router determines the value of the +controller+ and +action+ keys. These determine which controller
-  # and action are called. The remaining request parameters, the session (if one is available), and the full request with
-  # all the HTTP headers are made available to the action through accessor methods. Then the action is performed.
-  #
-  # The full request object is available via the request accessor and is primarily used to query for HTTP headers:
-  #
-  #   def server_ip
-  #     location = request.env["SERVER_ADDR"]
-  #     render :text => "This server hosted at #{location}"
-  #   end
-  #
-  # == Parameters
-  #
-  # All request parameters, whether they come from a GET or POST request, or from the URL, are available through the params method
-  # which returns a hash. For example, an action that was performed through <tt>/posts?category=All&limit=5</tt> will include
-  # <tt>{ "category" => "All", "limit" => "5" }</tt> in params.
-  #
-  # It's also possible to construct multi-dimensional parameter hashes by specifying keys using brackets, such as:
-  #
-  #   <input type="text" name="post[name]" value="david">
-  #   <input type="text" name="post[address]" value="hyacintvej">
-  #
-  # A request stemming from a form holding these inputs will include <tt>{ "post" => { "name" => "david", "address" => "hyacintvej" } }</tt>.
-  # If the address input had been named "post[address][street]", the params would have included
-  # <tt>{ "post" => { "address" => { "street" => "hyacintvej" } } }</tt>. There's no limit to the depth of the nesting.
-  #
-  # == Sessions
-  #
-  # Sessions allow you to store objects in between requests. This is useful for objects that are not yet ready to be persisted,
-  # such as a Signup object constructed in a multi-paged process, or objects that don't change much and are needed all the time, such
-  # as a User object for a system that requires login. The session should not be used, however, as a cache for objects where it's likely
-  # they could be changed unknowingly. It's usually too much work to keep it all synchronized -- something databases already excel at.
-  #
-  # You can place objects in the session by using the <tt>session</tt> method, which accesses a hash:
-  #
-  #   session[:person] = Person.authenticate(user_name, password)
-  #
-  # And retrieved again through the same hash:
-  #
-  #   Hello #{session[:person]}
-  #
-  # For removing objects from the session, you can either assign a single key to +nil+:
-  #
-  #   # removes :person from session
-  #   session[:person] = nil
-  #
-  # or you can remove the entire session with +reset_session+.
-  #
-  # Sessions are stored by default in a browser cookie that's cryptographically signed, but unencrypted.
-  # This prevents the user from tampering with the session but also allows him to see its contents.
-  #
-  # Do not put secret information in cookie-based sessions!
-  #
-  # Other options for session storage:
-  #
-  # * ActiveRecord::SessionStore - Sessions are stored in your database, which works better than PStore with multiple app servers and,
-  #   unlike CookieStore, hides your session contents from the user. To use ActiveRecord::SessionStore, set
-  #
-  #     MyApplication::Application.config.session_store :active_record_store
-  #
-  #   in your <tt>config/initializers/session_store.rb</tt> and run <tt>script/rails g session_migration</tt>.
-  #
-  # == Responses
-  #
-  # Each action results in a response, which holds the headers and document to be sent to the user's browser. The actual response
-  # object is generated automatically through the use of renders and redirects and requires no user intervention.
-  #
-  # == Renders
-  #
-  # Action Controller sends content to the user by using one of five rendering methods. The most versatile and common is the rendering
-  # of a template. Included in the Action Pack is the Action View, which enables rendering of ERB templates. It's automatically configured.
-  # The controller passes objects to the view by assigning instance variables:
-  #
-  #   def show
-  #     @post = Post.find(params[:id])
-  #   end
-  #
-  # Which are then automatically available to the view:
-  #
-  #   Title: <%= @post.title %>
-  #
-  # You don't have to rely on the automated rendering. For example, actions that could result in the rendering of different templates 
-  # will use the manual rendering methods:
-  #
-  #   def search
-  #     @results = Search.find(params[:query])
-  #     case @results.count
-  #       when 0 then render :action => "no_results"
-  #       when 1 then render :action => "show"
-  #       when 2..10 then render :action => "show_many"
-  #     end
-  #   end
-  #
-  # Read more about writing ERB and Builder templates in ActionView::Base.
-  #
-  # == Redirects
-  #
-  # Redirects are used to move from one action to another. For example, after a <tt>create</tt> action, which stores a blog entry to the
-  # database, we might like to show the user the new entry. Because we're following good DRY principles (Don't Repeat Yourself), we're 
-  # going to reuse (and redirect to) a <tt>show</tt> action that we'll assume has already been created. The code might look like this:
-  #
-  #   def create
-  #     @entry = Entry.new(params[:entry])
-  #     if @entry.save
-  #       # The entry was saved correctly, redirect to show
-  #       redirect_to :action => 'show', :id => @entry.id
-  #     else
-  #       # things didn't go so well, do something else
-  #     end
-  #   end
-  #
-  # In this case, after saving our new entry to the database, the user is redirected to the <tt>show</tt> method, which is then executed.
-  # Note that this is an external HTTP-level redirection which will cause the browser to make a second request (a GET to the show action),
-  # and not some internal re-routing which calls both "create" and then "show" within one request.
-  #
-  # Learn more about <tt>redirect_to</tt> and what options you have in ActionController::Redirecting.
-  #
-  # == Calling multiple redirects or renders
-  #
-  # An action may contain only a single render or a single redirect. Attempting to try to do either again will result in a DoubleRenderError:
-  #
-  #   def do_something
-  #     redirect_to :action => "elsewhere"
-  #     render :action => "overthere" # raises DoubleRenderError
-  #   end
-  #
-  # If you need to redirect on the condition of something, then be sure to add "and return" to halt execution.
-  #
-  #   def do_something
-  #     redirect_to(:action => "elsewhere") and return if monkeys.nil?
-  #     render :action => "overthere" # won't be called if monkeys is nil
-  #   end
-  #
-  class Base < Metal
-    abstract!
-
-    def self.without_modules(*modules)
-      modules = modules.map do |m|
-        m.is_a?(Symbol) ? ActionController.const_get(m) : m
-      end
-
-      MODULES - modules
-    end
-
-    MODULES = [
-      AbstractController::Layouts,
-      AbstractController::Translation,
-      AbstractController::AssetPaths,
-
-      Helpers,
-      HideActions,
-      UrlFor,
-      Redirecting,
-      Rendering,
-      Renderers::All,
-      ConditionalGet,
-      RackDelegation,
-      Caching,
-      MimeResponds,
-      ImplicitRender,
-
-      Cookies,
-      Flash,
-      RequestForgeryProtection,
-      ForceSSL,
-      Streaming,
-      DataStreaming,
-      RecordIdentifier,
-      HttpAuthentication::Basic::ControllerMethods,
-      HttpAuthentication::Digest::ControllerMethods,
-      HttpAuthentication::Token::ControllerMethods,
-
-      # Before callbacks should also be executed the earliest as possible, so
-      # also include them at the bottom.
-      AbstractController::Callbacks,
-
-      # Append rescue at the bottom to wrap as much as possible.
-      Rescue,
-
-      # Add instrumentations hooks at the bottom, to ensure they instrument
-      # all the methods properly.
-      Instrumentation,
-
-      # Params wrapper should come before instrumentation so they are
-      # properly showed in logs
-      ParamsWrapper
-    ]
-
-    MODULES.each do |mod|
-      include mod
-    end
-
-    # Rails 2.x compatibility
-    include ActionController::Compatibility
-
-    ActiveSupport.run_load_hooks(:action_controller, self)
-  end
-end