jquery_regex 0.0.1

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

@@ -0,0 +1,96 @@
+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.9/lib/abstract_controller.rb

@@ -0,0 +1,28 @@
+activesupport_path = File.expand_path('../../../activesupport/lib', __FILE__)
+$:.unshift(activesupport_path) if File.directory?(activesupport_path) && !$:.include?(activesupport_path)
+
+require 'action_pack'
+require 'active_support/concern'
+require 'active_support/ruby/shim'
+require 'active_support/dependencies/autoload'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/module/attr_internal'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/module/anonymous'
+require 'active_support/i18n'
+
+module AbstractController
+  extend ActiveSupport::Autoload
+
+  autoload :Base
+  autoload :Callbacks
+  autoload :Collector
+  autoload :Helpers
+  autoload :Layouts
+  autoload :Logger
+  autoload :Rendering
+  autoload :Translation
+  autoload :AssetPaths
+  autoload :ViewPaths
+  autoload :UrlFor
+end

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

@@ -0,0 +1,235 @@
+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

data/vendor/bundle/gems/actionpack-3.2.9/lib/action_controller/caching/actions.rb

@@ -0,0 +1,185 @@
+require 'set'
+
+module ActionController #:nodoc:
+  module Caching
+    # Action caching is similar to page caching by the fact that the entire
+    # output of the response is cached, but unlike page caching, every
+    # request still goes through Action Pack. The key benefit of this is
+    # that filters run before the cache is served, which allows for
+    # authentication and other restrictions on whether someone is allowed
+    # to execute such action. Example:
+    #
+    #   class ListsController < ApplicationController
+    #     before_filter :authenticate, :except => :public
+    #
+    #     caches_page   :public
+    #     caches_action :index, :show
+    #   end
+    #
+    # In this example, the +public+ action doesn't require authentication
+    # so it's possible to use the faster page caching. On the other hand
+    # +index+ and +show+ require authentication. They can still be cached,
+    # but we need action caching for them.
+    #
+    # Action caching uses fragment caching internally and an around
+    # filter to do the job. The fragment cache is named according to
+    # the host and path of the request. A page that is accessed at
+    # <tt>http://david.example.com/lists/show/1</tt> will result in a fragment named
+    # <tt>david.example.com/lists/show/1</tt>. This allows the cacher to
+    # differentiate between <tt>david.example.com/lists/</tt> and
+    # <tt>jamis.example.com/lists/</tt> -- which is a helpful way of assisting
+    # the subdomain-as-account-key pattern.
+    #
+    # Different representations of the same resource, e.g.
+    # <tt>http://david.example.com/lists</tt> and
+    # <tt>http://david.example.com/lists.xml</tt>
+    # are treated like separate requests and so are cached separately.
+    # Keep in mind when expiring an action cache that
+    # <tt>:action => 'lists'</tt> is not the same as
+    # <tt>:action => 'list', :format => :xml</tt>.
+    #
+    # You can modify the default action cache path by passing a
+    # <tt>:cache_path</tt> option. This will be passed directly to
+    # <tt>ActionCachePath.path_for</tt>. This is handy for actions with
+    # multiple possible routes that should be cached differently. If a
+    # block is given, it is called with the current controller instance.
+    #
+    # And you can also use <tt>:if</tt> (or <tt>:unless</tt>) to pass a
+    # proc that specifies when the action should be cached.
+    #
+    # Finally, if you are using memcached, you can also pass <tt>:expires_in</tt>.
+    #
+    # The following example depicts some of the points made above:
+    #
+    #   class ListsController < ApplicationController
+    #     before_filter :authenticate, :except => :public
+    #
+    #     caches_page :public
+    #
+    #     caches_action :index, :if => proc do
+    #       !request.format.json?  # cache if is not a JSON request
+    #     end
+    #
+    #     caches_action :show, :cache_path => { :project => 1 },
+    #       :expires_in => 1.hour
+    #
+    #     caches_action :feed, :cache_path => proc do
+    #       if params[:user_id]
+    #         user_list_url(params[:user_id, params[:id])
+    #       else
+    #         list_url(params[:id])
+    #       end
+    #     end
+    #   end
+    #
+    # If you pass <tt>:layout => false</tt>, it will only cache your action
+    # content. That's useful when your layout has dynamic information.
+    #
+    # Warning: If the format of the request is determined by the Accept HTTP
+    # header the Content-Type of the cached response could be wrong because
+    # no information about the MIME type is stored in the cache key. So, if
+    # you first ask for MIME type M in the Accept header, a cache entry is
+    # created, and then perform a second request to the same resource asking
+    # for a different MIME type, you'd get the content cached for M.
+    #
+    # The <tt>:format</tt> parameter is taken into account though. The safest
+    # way to cache by MIME type is to pass the format in the route.
+    module Actions
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Declares that +actions+ should be cached.
+        # See ActionController::Caching::Actions for details.
+        def caches_action(*actions)
+          return unless cache_configured?
+          options = actions.extract_options!
+          options[:layout] = true unless options.key?(:layout)
+          filter_options = options.extract!(:if, :unless).merge(:only => actions)
+          cache_options  = options.extract!(:layout, :cache_path).merge(:store_options => options)
+
+          around_filter ActionCacheFilter.new(cache_options), filter_options
+        end
+      end
+
+      def _save_fragment(name, options)
+        content = ""
+        response_body.each do |parts|
+          content << parts
+        end
+
+        if caching_allowed?
+          write_fragment(name, content, options)
+        else
+          content
+        end
+      end
+
+    protected
+      def expire_action(options = {})
+        return unless cache_configured?
+
+        if options.is_a?(Hash) && options[:action].is_a?(Array)
+          options[:action].each {|action| expire_action(options.merge(:action => action)) }
+        else
+          expire_fragment(ActionCachePath.new(self, options, false).path)
+        end
+      end
+
+      class ActionCacheFilter #:nodoc:
+        def initialize(options, &block)
+          @cache_path, @store_options, @cache_layout =
+            options.values_at(:cache_path, :store_options, :layout)
+        end
+
+        def filter(controller)
+          path_options = if @cache_path.respond_to?(:call)
+            controller.instance_exec(controller, &@cache_path)
+          else
+            @cache_path
+          end
+
+          cache_path = ActionCachePath.new(controller, path_options || {})
+
+          body = controller.read_fragment(cache_path.path, @store_options)
+
+          unless body
+            controller.action_has_layout = false unless @cache_layout
+            yield
+            controller.action_has_layout = true
+            body = controller._save_fragment(cache_path.path, @store_options)
+          end
+
+          body = controller.render_to_string(:text => body, :layout => true) unless @cache_layout
+
+          controller.response_body = body
+          controller.content_type = Mime[cache_path.extension || :html]
+        end
+      end
+
+      class ActionCachePath
+        attr_reader :path, :extension
+
+        # If +infer_extension+ is true, the cache path extension is looked up from the request's
+        # path and format. This is desirable when reading and writing the cache, but not when
+        # expiring the cache - expire_action should expire the same files regardless of the
+        # request format.
+        def initialize(controller, options = {}, infer_extension = true)
+          if infer_extension
+            @extension = controller.params[:format]
+            options.reverse_merge!(:format => @extension) if options.is_a?(Hash)
+          end
+
+          path = controller.url_for(options).split(%r{://}).last
+          @path = normalize!(path)
+        end
+
+      private
+        def normalize!(path)
+          path << 'index' if path[-1] == ?/
+          path << ".#{extension}" if extension and !path.split('?').first.ends_with?(".#{extension}")
+          URI.parser.unescape(path)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/actionpack-3.2.9/lib/action_controller/caching/fragments.rb

@@ -0,0 +1,127 @@
+module ActionController #:nodoc:
+  module Caching
+    # Fragment caching is used for caching various blocks within 
+    # views without caching the entire action as a whole. This is
+    # useful when certain elements of an action change frequently or 
+    # depend on complicated state while other parts rarely change or 
+    # can be shared amongst multiple parties. The caching is done using
+    # the <tt>cache</tt> helper available in the Action View. A 
+    # template with fragment caching might look like:
+    #
+    #   <b>Hello <%= @name %></b>
+    #
+    #   <% cache do %>
+    #     All the topics in the system:
+    #     <%= render :partial => "topic", :collection => Topic.all %>
+    #   <% end %>
+    #
+    # This cache will bind the name of the action that called it, so if
+    # this code was part of the view for the topics/list action, you 
+    # would be able to invalidate it using:
+    #
+    #   expire_fragment(:controller => "topics", :action => "list")
+    #
+    # This default behavior is limited if you need to cache multiple 
+    # fragments per action or if the action itself is cached using 
+    # <tt>caches_action</tt>. To remedy this, there is an option to 
+    # qualify the name of the cached fragment by using the 
+    # <tt>:action_suffix</tt> option:
+    #
+    #   <% cache(:action => "list", :action_suffix => "all_topics") do %>
+    #
+    # That would result in a name such as 
+    # <tt>/topics/list/all_topics</tt>, avoiding conflicts with the 
+    # action cache and with any fragments that use a different suffix.
+    # Note that the URL doesn't have to really exist or be callable
+    # - the url_for system is just used to generate unique cache names
+    # that we can refer to when we need to expire the cache.
+    #
+    # The expiration call for this example is:
+    #
+    #   expire_fragment(:controller => "topics", 
+    #                   :action => "list", 
+    #                   :action_suffix => "all_topics")
+    module Fragments
+      # Given a key (as described in <tt>expire_fragment</tt>), returns
+      # a key suitable for use in reading, writing, or expiring a 
+      # cached fragment. If the key is a hash, the generated key is the
+      # return value of url_for on that hash (without the protocol). 
+      # All keys are prefixed with <tt>views/</tt> and uses
+      # ActiveSupport::Cache.expand_cache_key for the expansion.
+      def fragment_cache_key(key)
+        ActiveSupport::Cache.expand_cache_key(key.is_a?(Hash) ? url_for(key).split("://").last : key, :views)
+      end
+
+      # Writes <tt>content</tt> to the location signified by 
+      # <tt>key</tt> (see <tt>expire_fragment</tt> for acceptable formats).
+      def write_fragment(key, content, options = nil)
+        return content unless cache_configured?
+
+        key = fragment_cache_key(key)
+        instrument_fragment_cache :write_fragment, key do
+          content = content.to_str
+          cache_store.write(key, content, options)
+        end
+        content
+      end
+
+      # Reads a cached fragment from the location signified by <tt>key</tt>
+      # (see <tt>expire_fragment</tt> for acceptable formats).
+      def read_fragment(key, options = nil)
+        return unless cache_configured?
+
+        key = fragment_cache_key(key)
+        instrument_fragment_cache :read_fragment, key do
+          result = cache_store.read(key, options)
+          result.respond_to?(:html_safe) ? result.html_safe : result
+        end
+      end
+
+      # Check if a cached fragment from the location signified by 
+      # <tt>key</tt> exists (see <tt>expire_fragment</tt> for acceptable formats)
+      def fragment_exist?(key, options = nil)
+        return unless cache_configured?
+        key = fragment_cache_key(key)
+
+        instrument_fragment_cache :exist_fragment?, key do
+          cache_store.exist?(key, options)
+        end
+      end
+
+      # Removes fragments from the cache.
+      #
+      # +key+ can take one of three forms:
+      #
+      # * String - This would normally take the form of a path, like
+      #   <tt>pages/45/notes</tt>.
+      # * Hash - Treated as an implicit call to +url_for+, like
+      #   <tt>{:controller => "pages", :action => "notes", :id => 45}</tt>
+      # * Regexp - Will remove any fragment that matches, so
+      #   <tt>%r{pages/\d*/notes}</tt> might remove all notes. Make sure you
+      #   don't use anchors in the regex (<tt>^</tt> or <tt>$</tt>) because
+      #   the actual filename matched looks like
+      #   <tt>./cache/filename/path.cache</tt>. Note: Regexp expiration is
+      #   only supported on caches that can iterate over all keys (unlike
+      #   memcached).
+      #
+      # +options+ is passed through to the cache store's <tt>delete</tt>
+      # method (or <tt>delete_matched</tt>, for Regexp keys.)
+      def expire_fragment(key, options = nil)
+        return unless cache_configured?
+        key = fragment_cache_key(key) unless key.is_a?(Regexp)
+
+        instrument_fragment_cache :expire_fragment, key do
+          if key.is_a?(Regexp)
+            cache_store.delete_matched(key, options)
+          else
+            cache_store.delete(key, options)
+          end
+        end
+      end
+
+      def instrument_fragment_cache(name, key)
+        ActiveSupport::Notifications.instrument("#{name}.action_controller", :key => key){ yield }
+      end
+    end
+  end
+end