challah 1.0.0.beta → 1.0.0.beta2

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

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

@@ -1,97 +0,0 @@
-module ActionController #:nodoc:
-  module Caching
-    # Sweepers are the terminators of the caching world and responsible for expiring caches when model objects change.
-    # They do this by being half-observers, half-filters and implementing callbacks for both roles. A Sweeper example:
-    #
-    #   class ListSweeper < ActionController::Caching::Sweeper
-    #     observe List, Item
-    #
-    #     def after_save(record)
-    #       list = record.is_a?(List) ? record : record.list
-    #       expire_page(:controller => "lists", :action => %w( show public feed ), :id => list.id)
-    #       expire_action(:controller => "lists", :action => "all")
-    #       list.shares.each { |share| expire_page(:controller => "lists", :action => "show", :id => share.url_key) }
-    #     end
-    #   end
-    #
-    # The sweeper is assigned in the controllers that wish to have its job performed using the <tt>cache_sweeper</tt> class method:
-    #
-    #   class ListsController < ApplicationController
-    #     caches_action :index, :show, :public, :feed
-    #     cache_sweeper :list_sweeper, :only => [ :edit, :destroy, :share ]
-    #   end
-    #
-    # In the example above, four actions are cached and three actions are responsible for expiring those caches.
-    #
-    # You can also name an explicit class in the declaration of a sweeper, which is needed if the sweeper is in a module:
-    #
-    #   class ListsController < ApplicationController
-    #     caches_action :index, :show, :public, :feed
-    #     cache_sweeper OpenBar::Sweeper, :only => [ :edit, :destroy, :share ]
-    #   end
-    module Sweeping
-      extend ActiveSupport::Concern
-
-      module ClassMethods #:nodoc:
-        def cache_sweeper(*sweepers)
-          configuration = sweepers.extract_options!
-
-          sweepers.each do |sweeper|
-            ActiveRecord::Base.observers << sweeper if defined?(ActiveRecord) and defined?(ActiveRecord::Base)
-            sweeper_instance = (sweeper.is_a?(Symbol) ? Object.const_get(sweeper.to_s.classify) : sweeper).instance
-
-            if sweeper_instance.is_a?(Sweeper)
-              around_filter(sweeper_instance, :only => configuration[:only])
-            else
-              after_filter(sweeper_instance, :only => configuration[:only])
-            end
-          end
-        end
-      end
-    end
-
-    if defined?(ActiveRecord) and defined?(ActiveRecord::Observer)
-      class Sweeper < ActiveRecord::Observer #:nodoc:
-        attr_accessor :controller
-
-        def before(controller)
-          self.controller = controller
-          callback(:before) if controller.perform_caching
-          true # before method from sweeper should always return true
-        end
-
-        def after(controller)
-          self.controller = controller
-          callback(:after) if controller.perform_caching
-          # Clean up, so that the controller can be collected after this request
-          self.controller = nil
-        end
-
-        protected
-          # gets the action cache path for the given options.
-          def action_path_for(options)
-            Actions::ActionCachePath.new(controller, options).path
-          end
-
-          # Retrieve instance variables set in the controller.
-          def assigns(key)
-            controller.instance_variable_get("@#{key}")
-          end
-
-        private
-          def callback(timing)
-            controller_callback_method_name = "#{timing}_#{controller.controller_name.underscore}"
-            action_callback_method_name     = "#{controller_callback_method_name}_#{controller.action_name}"
-
-            __send__(controller_callback_method_name) if respond_to?(controller_callback_method_name, true)
-            __send__(action_callback_method_name)     if respond_to?(action_callback_method_name, true)
-          end
-
-          def method_missing(method, *arguments, &block)
-            return unless @controller
-            @controller.__send__(method, *arguments, &block)
-          end
-      end
-    end
-  end
-end

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/deprecated/integration_test.rb

@@ -1,2 +0,0 @@
-ActionController::Integration = ActionDispatch::Integration
-ActionController::IntegrationTest = ActionDispatch::IntegrationTest

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

@@ -1 +0,0 @@
-ActionController::PerformanceTest = ActionDispatch::PerformanceTest

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

@@ -1,3 +0,0 @@
-ActionController::AbstractRequest = ActionController::Request = ActionDispatch::Request
-ActionController::AbstractResponse = ActionController::Response = ActionDispatch::Response
-ActionController::Routing = ActionDispatch::Routing

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

@@ -1,67 +0,0 @@
-require 'active_support/core_ext/object/blank'
-
-module ActionController
-  class LogSubscriber < ActiveSupport::LogSubscriber
-    INTERNAL_PARAMS = %w(controller action format _method only_path)
-
-    def start_processing(event)
-      payload = event.payload
-      params  = payload[:params].except(*INTERNAL_PARAMS)
-      format  = payload[:format]
-      format  = format.to_s.upcase if format.is_a?(Symbol)
-
-      info "Processing by #{payload[:controller]}##{payload[:action]} as #{format}"
-      info "  Parameters: #{params.inspect}" unless params.empty?
-    end
-
-    def process_action(event)
-      payload   = event.payload
-      additions = ActionController::Base.log_process_action(payload)
-
-      status = payload[:status]
-      if status.nil? && payload[:exception].present?
-        exception_class_name = payload[:exception].first
-        status = ActionDispatch::ExceptionWrapper.status_code_for_exception(exception_class_name)
-      end
-      message = "Completed #{status} #{Rack::Utils::HTTP_STATUS_CODES[status]} in %.0fms" % event.duration
-      message << " (#{additions.join(" | ")})" unless additions.blank?
-
-      info(message)
-    end
-
-    def halted_callback(event)
-      info "Filter chain halted as #{event.payload[:filter]} rendered or redirected"
-    end
-
-    def send_file(event)
-      message = "Sent file %s"
-      message << " (%.1fms)"
-      info(message % [event.payload[:path], event.duration])
-    end
-
-    def redirect_to(event)
-      info "Redirected to #{event.payload[:location]}"
-    end
-
-    def send_data(event)
-      info("Sent data %s (%.1fms)" % [event.payload[:filename], event.duration])
-    end
-
-    %w(write_fragment read_fragment exist_fragment?
-       expire_fragment expire_page write_page).each do |method|
-      class_eval <<-METHOD, __FILE__, __LINE__ + 1
-        def #{method}(event)
-          key_or_path = event.payload[:key] || event.payload[:path]
-          human_name  = #{method.to_s.humanize.inspect}
-          info("\#{human_name} \#{key_or_path} \#{"(%.1fms)" % event.duration}")
-        end
-      METHOD
-    end
-
-    def logger
-      ActionController::Base.logger
-    end
-  end
-end
-
-ActionController::LogSubscriber.attach_to :action_controller

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

@@ -1,64 +0,0 @@
-require 'active_support/deprecation'
-
-module ActionController
-  module Compatibility
-    extend ActiveSupport::Concern
-
-    # Temporary hax
-    included do
-      ::ActionController::UnknownAction = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('ActionController::UnknownAction', '::AbstractController::ActionNotFound')
-      ::ActionController::DoubleRenderError = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('ActionController::DoubleRenderError', '::AbstractController::DoubleRenderError')
-
-      # ROUTES TODO: This should be handled by a middleware and route generation
-      # should be able to handle SCRIPT_NAME
-      self.config.relative_url_root = ENV['RAILS_RELATIVE_URL_ROOT']
-
-      def self.default_charset=(new_charset)
-        ActiveSupport::Deprecation.warn "Setting default charset at controller level" \
-          " is deprecated, please use `config.action_dispatch.default_charset` instead", caller
-        ActionDispatch::Response.default_charset = new_charset
-      end
-
-      self.protected_instance_variables = %w(
-        @_status @_headers @_params @_env @_response @_request
-        @_view_runtime @_stream @_url_options @_action_has_layout
-      )
-
-      def rescue_action(env)
-        ActiveSupport::Deprecation.warn "Calling `rescue_action` is deprecated and will be removed in Rails 4.0.", caller
-        raise env["action_dispatch.rescue.exception"]
-      end
-    end
-
-    # For old tests
-    def initialize_template_class(*)
-      ActiveSupport::Deprecation.warn "Calling `initialize_template_class` is deprecated and has no effect anymore.", caller
-    end
-
-    def assign_shortcuts(*)
-      ActiveSupport::Deprecation.warn "Calling `assign_shortcuts` is deprecated and has no effect anymore.", caller
-    end
-
-    def _normalize_options(options)
-      options[:text] = nil if options.delete(:nothing) == true
-      options[:text] = " " if options.key?(:text) && options[:text].nil?
-      super
-    end
-
-    def render_to_body(options)
-      options[:template].sub!(/^\//, '') if options.key?(:template)
-      super || " "
-    end
-
-    def _handle_method_missing
-      ActiveSupport::Deprecation.warn "Using `method_missing` to handle non" \
-        " existing actions is deprecated and will be removed in Rails 4.0, " \
-        " please use `action_missing` instead.", caller
-      method_missing(@_action_name.to_sym)
-    end
-
-    def method_for_action(action_name)
-      super || (respond_to?(:method_missing) && "_handle_method_missing")
-    end
-  end
-end

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

@@ -1,131 +0,0 @@
-module ActionController
-  module ConditionalGet
-    extend ActiveSupport::Concern
-
-    include RackDelegation
-    include Head
-
-    # Sets the etag, last_modified, or both on the response and renders a
-    # <tt>304 Not Modified</tt> response if the request is already fresh.
-    #
-    # Parameters:
-    # * <tt>:etag</tt>
-    # * <tt>:last_modified</tt>
-    # * <tt>:public</tt> By default the Cache-Control header is private, set this to true if you want your application to be cachable by other devices (proxy caches).
-    #
-    # Example:
-    #
-    #   def show
-    #     @article = Article.find(params[:id])
-    #     fresh_when(:etag => @article, :last_modified => @article.created_at, :public => true)
-    #   end
-    #
-    # This will render the show template if the request isn't sending a matching etag or
-    # If-Modified-Since header and just a <tt>304 Not Modified</tt> response if there's a match.
-    #
-    # You can also just pass a record where last_modified will be set by calling updated_at and the etag by passing the object itself. Example:
-    #
-    #   def show
-    #     @article = Article.find(params[:id])
-    #     fresh_when(@article)
-    #   end
-    #
-    # When passing a record, you can still set whether the public header:
-    #
-    #   def show
-    #     @article = Article.find(params[:id])
-    #     fresh_when(@article, :public => true)
-    #   end
-    def fresh_when(record_or_options, additional_options = {})
-      if record_or_options.is_a? Hash
-        options = record_or_options
-        options.assert_valid_keys(:etag, :last_modified, :public)
-      else
-        record  = record_or_options
-        options = { :etag => record, :last_modified => record.try(:updated_at) }.merge(additional_options)
-      end
-
-      response.etag          = options[:etag]          if options[:etag]
-      response.last_modified = options[:last_modified] if options[:last_modified]
-      response.cache_control[:public] = true if options[:public]
-
-      head :not_modified if request.fresh?(response)
-    end
-
-    # Sets the etag and/or last_modified on the response and checks it against
-    # the client request. If the request doesn't match the options provided, the
-    # request is considered stale and should be generated from scratch. Otherwise,
-    # it's fresh and we don't need to generate anything and a reply of <tt>304 Not Modified</tt> is sent.
-    #
-    # Parameters:
-    # * <tt>:etag</tt>
-    # * <tt>:last_modified</tt>
-    # * <tt>:public</tt> By default the Cache-Control header is private, set this to true if you want your application to be cachable by other devices (proxy caches).
-    #
-    # Example:
-    #
-    #   def show
-    #     @article = Article.find(params[:id])
-    #
-    #     if stale?(:etag => @article, :last_modified => @article.created_at)
-    #       @statistics = @article.really_expensive_call
-    #       respond_to do |format|
-    #         # all the supported formats
-    #       end
-    #     end
-    #   end
-    #
-    # You can also just pass a record where last_modified will be set by calling updated_at and the etag by passing the object itself. Example:
-    #
-    #   def show
-    #     @article = Article.find(params[:id])
-    #
-    #     if stale?(@article)
-    #       @statistics = @article.really_expensive_call
-    #       respond_to do |format|
-    #         # all the supported formats
-    #       end
-    #     end
-    #   end
-    #
-    # When passing a record, you can still set whether the public header:
-    #
-    #   def show
-    #     @article = Article.find(params[:id])
-    #
-    #     if stale?(@article, :public => true)
-    #       @statistics = @article.really_expensive_call
-    #       respond_to do |format|
-    #         # all the supported formats
-    #       end
-    #     end
-    #   end
-    def stale?(record_or_options, additional_options = {})
-      fresh_when(record_or_options, additional_options)
-      !request.fresh?(response)
-    end
-
-    # Sets a HTTP 1.1 Cache-Control header. Defaults to issuing a <tt>private</tt> instruction, so that
-    # intermediate caches must not cache the response.
-    #
-    # Examples:
-    #   expires_in 20.minutes
-    #   expires_in 3.hours, :public => true
-    #   expires_in 3.hours, 'max-stale' => 5.hours, :public => true
-    #
-    # This method will overwrite an existing Cache-Control header.
-    # See http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html for more possibilities.
-    def expires_in(seconds, options = {}) #:doc:
-      response.cache_control.merge!(:max_age => seconds, :public => options.delete(:public))
-      options.delete(:private)
-
-      response.cache_control[:extras] = options.map {|k,v| "#{k}=#{v}"}
-    end
-
-    # Sets a HTTP 1.1 Cache-Control header of <tt>no-cache</tt> so no caching should occur by the browser or
-    # intermediate caches (like caching proxy servers).
-    def expires_now #:doc:
-      response.cache_control.replace(:no_cache => true)
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-module ActionController #:nodoc:
-  module Cookies
-    extend ActiveSupport::Concern
-
-    include RackDelegation
-
-    included do
-      helper_method :cookies
-    end
-
-    private
-      def cookies
-        request.cookie_jar
-      end
-  end
-end