backbone-deep-rails 0.0.1 → 0.0.2

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

@@ -1,86 +0,0 @@
-require 'fileutils'
-require 'uri'
-require 'set'
-
-module ActionController #:nodoc:
-  # \Caching is a cheap way of speeding up slow applications by keeping the result of
-  # calculations, renderings, and database calls around for subsequent requests.
-  # Action Controller affords you three approaches in varying levels of granularity:
-  # Page, Action, Fragment.
-  #
-  # You can read more about each approach and the sweeping assistance by clicking the
-  # modules below.
-  #
-  # Note: To turn off all caching and sweeping, set
-  #   config.action_controller.perform_caching = false.
-  #
-  # == \Caching stores
-  #
-  # All the caching stores from ActiveSupport::Cache are available to be used as backends
-  # for Action Controller caching. This setting only affects action and fragment caching
-  # as page caching is always written to disk.
-  #
-  # Configuration examples (MemoryStore is the default):
-  #
-  #   config.action_controller.cache_store = :memory_store
-  #   config.action_controller.cache_store = :file_store, "/path/to/cache/directory"
-  #   config.action_controller.cache_store = :mem_cache_store, "localhost"
-  #   config.action_controller.cache_store = :mem_cache_store, Memcached::Rails.new("localhost:11211")
-  #   config.action_controller.cache_store = MyOwnStore.new("parameter")
-  module Caching
-    extend ActiveSupport::Concern
-    extend ActiveSupport::Autoload
-
-    eager_autoload do
-      autoload :Actions
-      autoload :Fragments
-      autoload :Pages
-      autoload :Sweeper, 'action_controller/caching/sweeping'
-      autoload :Sweeping, 'action_controller/caching/sweeping'
-    end
-
-    module ConfigMethods
-      def cache_store
-        config.cache_store
-      end
-
-      def cache_store=(store)
-        config.cache_store = ActiveSupport::Cache.lookup_store(store)
-      end
-
-    private
-
-      def cache_configured?
-        perform_caching && cache_store
-      end
-    end
-
-    include RackDelegation
-    include AbstractController::Callbacks
-
-    include ConfigMethods
-    include Pages, Actions, Fragments
-    include Sweeping if defined?(ActiveRecord)
-
-    included do
-      extend ConfigMethods
-
-      config_accessor :perform_caching
-      self.perform_caching = true if perform_caching.nil?
-    end
-
-    def caching_allowed?
-      request.get? && response.status == 200
-    end
-
-  protected
-    # Convenience accessor
-    def cache(key, options = {}, &block)
-      if cache_configured?
-        cache_store.fetch(ActiveSupport::Cache.expand_cache_key(key, :controller), options, &block)
-      else
-        yield
-      end
-    end
-  end
-end

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

@@ -1,185 +0,0 @@
-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.11/lib/action_controller/caching/fragments.rb

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

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

@@ -1,187 +0,0 @@
-require 'fileutils'
-require 'active_support/core_ext/class/attribute_accessors'
-
-module ActionController #:nodoc:
-  module Caching
-    # Page caching is an approach to caching where the entire action output of is stored as a HTML file that the web server
-    # can serve without going through Action Pack. This is the fastest way to cache your content as opposed to going dynamically
-    # through the process of generating the content. Unfortunately, this incredible speed-up is only available to stateless pages
-    # where all visitors are treated the same. Content management systems -- including weblogs and wikis -- have many pages that are
-    # a great fit for this approach, but account-based systems where people log in and manipulate their own data are often less
-    # likely candidates.
-    #
-    # Specifying which actions to cache is done through the <tt>caches_page</tt> class method:
-    #
-    #   class WeblogController < ActionController::Base
-    #     caches_page :show, :new
-    #   end
-    #
-    # This will generate cache files such as <tt>weblog/show/5.html</tt> and <tt>weblog/new.html</tt>, which match the URLs used
-    # that would normally trigger dynamic page generation. Page caching works by configuring a web server to first check for the
-    # existence of files on disk, and to serve them directly when found, without passing the request through to Action Pack.
-    # This is much faster than handling the full dynamic request in the usual way.
-    #
-    # Expiration of the cache is handled by deleting the cached file, which results in a lazy regeneration approach where the cache
-    # is not restored before another hit is made against it. The API for doing so mimics the options from +url_for+ and friends:
-    #
-    #   class WeblogController < ActionController::Base
-    #     def update
-    #       List.update(params[:list][:id], params[:list])
-    #       expire_page :action => "show", :id => params[:list][:id]
-    #       redirect_to :action => "show", :id => params[:list][:id]
-    #     end
-    #   end
-    #
-    # Additionally, you can expire caches using Sweepers that act on changes in the model to determine when a cache is supposed to be
-    # expired.
-    module Pages
-      extend ActiveSupport::Concern
-
-      included do
-        # The cache directory should be the document root for the web server and is set using <tt>Base.page_cache_directory = "/document/root"</tt>.
-        # For Rails, this directory has already been set to Rails.public_path (which is usually set to <tt>Rails.root + "/public"</tt>). Changing
-        # this setting can be useful to avoid naming conflicts with files in <tt>public/</tt>, but doing so will likely require configuring your
-        # web server to look in the new location for cached files.
-        class_attribute :page_cache_directory
-        self.page_cache_directory ||= ''
-
-        # Most Rails requests do not have an extension, such as <tt>/weblog/new</tt>. In these cases, the page caching mechanism will add one in
-        # order to make it easy for the cached files to be picked up properly by the web server. By default, this cache extension is <tt>.html</tt>.
-        # If you want something else, like <tt>.php</tt> or <tt>.shtml</tt>, just set Base.page_cache_extension. In cases where a request already has an
-        # extension, such as <tt>.xml</tt> or <tt>.rss</tt>, page caching will not add an extension. This allows it to work well with RESTful apps.
-        class_attribute :page_cache_extension
-        self.page_cache_extension ||= '.html'
-
-        # The compression used for gzip. If false (default), the page is not compressed.
-        # If can be a symbol showing the ZLib compression method, for example, :best_compression
-        # or :best_speed or an integer configuring the compression level.
-        class_attribute :page_cache_compression
-        self.page_cache_compression ||= false
-      end
-
-      module ClassMethods
-        # Expires the page that was cached with the +path+ as a key. Example:
-        #   expire_page "/lists/show"
-        def expire_page(path)
-          return unless perform_caching
-          path = page_cache_path(path)
-
-          instrument_page_cache :expire_page, path do
-            File.delete(path) if File.exist?(path)
-            File.delete(path + '.gz') if File.exist?(path + '.gz')
-          end
-        end
-
-        # Manually cache the +content+ in the key determined by +path+. Example:
-        #   cache_page "I'm the cached content", "/lists/show"
-        def cache_page(content, path, extension = nil, gzip = Zlib::BEST_COMPRESSION)
-          return unless perform_caching
-          path = page_cache_path(path, extension)
-
-          instrument_page_cache :write_page, path do
-            FileUtils.makedirs(File.dirname(path))
-            File.open(path, "wb+") { |f| f.write(content) }
-            if gzip
-              Zlib::GzipWriter.open(path + '.gz', gzip) { |f| f.write(content) }
-            end
-          end
-        end
-
-        # Caches the +actions+ using the page-caching approach that'll store
-        # the cache in a path within the page_cache_directory that
-        # matches the triggering url.
-        #
-        # You can also pass a :gzip option to override the class configuration one.
-        #
-        # Usage:
-        #
-        #   # cache the index action
-        #   caches_page :index
-        #
-        #   # cache the index action except for JSON requests
-        #   caches_page :index, :if => Proc.new { |c| !c.request.format.json? }
-        #
-        #   # don't gzip images
-        #   caches_page :image, :gzip => false
-        def caches_page(*actions)
-          return unless perform_caching
-          options = actions.extract_options!
-
-          gzip_level = options.fetch(:gzip, page_cache_compression)
-          gzip_level = case gzip_level
-          when Symbol
-            Zlib.const_get(gzip_level.to_s.upcase)
-          when Fixnum
-            gzip_level
-          when false
-            nil
-          else
-            Zlib::BEST_COMPRESSION
-          end
-
-          after_filter({:only => actions}.merge(options)) do |c|
-            c.cache_page(nil, nil, gzip_level)
-          end
-        end
-
-        private
-          def page_cache_file(path, extension)
-            name = (path.empty? || path == "/") ? "/index" : URI.parser.unescape(path.chomp('/'))
-            unless (name.split('/').last || name).include? '.'
-              name << (extension || self.page_cache_extension)
-            end
-            return name
-          end
-
-          def page_cache_path(path, extension = nil)
-            page_cache_directory.to_s + page_cache_file(path, extension)
-          end
-
-          def instrument_page_cache(name, path)
-            ActiveSupport::Notifications.instrument("#{name}.action_controller", :path => path){ yield }
-          end
-      end
-
-      # Expires the page that was cached with the +options+ as a key. Example:
-      #   expire_page :controller => "lists", :action => "show"
-      def expire_page(options = {})
-        return unless self.class.perform_caching
-
-        if options.is_a?(Hash)
-          if options[:action].is_a?(Array)
-            options[:action].each do |action|
-              self.class.expire_page(url_for(options.merge(:only_path => true, :action => action)))
-            end
-          else
-            self.class.expire_page(url_for(options.merge(:only_path => true)))
-          end
-        else
-          self.class.expire_page(options)
-        end
-      end
-
-      # Manually cache the +content+ in the key determined by +options+. If no content is provided, the contents of response.body is used.
-      # If no options are provided, the url of the current request being handled is used. Example:
-      #   cache_page "I'm the cached content", :controller => "lists", :action => "show"
-      def cache_page(content = nil, options = nil, gzip = Zlib::BEST_COMPRESSION)
-        return unless self.class.perform_caching && caching_allowed?
-
-        path = case options
-          when Hash
-            url_for(options.merge(:only_path => true, :format => params[:format]))
-          when String
-            options
-          else
-            request.path
-        end
-
-        if (type = Mime::LOOKUP[self.content_type]) && (type_symbol = type.symbol).present?
-          extension = ".#{type_symbol}"
-        end
-
-        self.class.cache_page(content || response.body, path, extension, gzip)
-      end
-
-    end
-  end
-end