RubyGems - challah - Versions diffs - 0.5.0 → 0.5.1 - Mend

challah 0.5.0 → 0.5.1

Files changed (2875) hide show

data/vendor/bundle/gems/actionpack-3.2.1/README.rdoc DELETED Viewed

@@ -1,341 +0,0 @@
-= Action Pack -- From request to response
-Action Pack is a framework for handling and responding to web requests. It
-provides mechanisms for *routing* (mapping request URLs to actions), defining
-*controllers* that implement actions, and generating responses by rendering
-*views*, which are templates of various formats. In short, Action Pack
-provides the view and controller layers in the MVC paradigm.
-It consists of several modules:
-* Action Dispatch, which parses information about the web request, handles
-  routing as defined by the user, and does advanced processing related to HTTP
-  such as MIME-type negotiation, decoding parameters in POST/PUT bodies,
-  handling HTTP caching logic, cookies and sessions.
-* Action Controller, which provides a base controller class that can be
-  subclassed to implement filters and actions to handle requests. The result
-  of an action is typically content generated from views.
-* Action View, which handles view template lookup and rendering, and provides
-  view helpers that assist when building HTML forms, Atom feeds and more.
-  Template formats that Action View handles are ERB (embedded Ruby, typically
-  used to inline short Ruby snippets inside HTML), and XML Builder.
-With the Ruby on Rails framework, users only directly interface with the
-Action Controller module. Necessary Action Dispatch functionality is activated
-by default and Action View rendering is implicitly triggered by Action
-Controller. However, these modules are designed to function on their own and
-can be used outside of Rails.
-A short rundown of some of the major features:
-* Actions grouped in controller as methods instead of separate command objects
-  and can therefore share helper methods
-    class CustomersController < ActionController::Base
-      def show
-        @customer = find_customer
-      end
-      def update
-        @customer = find_customer
-        if @customer.update_attributes(params[:customer])
-          redirect_to :action => "show"
-        else
-          render :action => "edit"
-        end
-      end
-      private
-        def find_customer
-          Customer.find params[:id]
-        end
-    end
-  {Learn more}[link:classes/ActionController/Base.html]
-* ERB templates (static content mixed with dynamic output from ruby)
-    <% @posts.each do |post| %>
-      Title: <%= post.title %>
-    <% end %>
-    All post titles: <%= @posts.collect{ |p| p.title }.join(", ") %>
-    <% unless @person.is_client? %>
-      Not for clients to see...
-    <% end %>
-  {Learn more}[link:classes/ActionView.html]
-* "Builder" templates (great for XML content, like RSS)
-    xml.rss("version" => "2.0") do
-      xml.channel do
-        xml.title(@feed_title)
-        xml.link(@url)
-        xml.description "Basecamp: Recent items"
-        xml.language "en-us"
-        xml.ttl "40"
-        @recent_items.each do |item|
-          xml.item do
-            xml.title(item_title(item))
-            xml.description(item_description(item))
-            xml.pubDate(item_pubDate(item))
-            xml.guid(@recent_items.url(item))
-            xml.link(@recent_items.url(item))
-          end
-        end
-      end
-    end
-  {Learn more}[link:classes/ActionView/Base.html]
-* Filters for pre- and post-processing of the response
-    class WeblogController < ActionController::Base
-      # filters as methods
-      before_filter :authenticate, :cache, :audit
-      # filter as a proc
-      after_filter { |c| c.response.body = Gzip::compress(c.response.body) }
-      # class filter
-      after_filter LocalizeFilter
-      def index
-        # Before this action is run, the user will be authenticated, the cache
-        # will be examined to see if a valid copy of the results already
-        # exists, and the action will be logged for auditing.
-        # After this action has run, the output will first be localized then
-        # compressed to minimize bandwidth usage
-      end
-      private
-        def authenticate
-          # Implement the filter with full access to both request and response
-        end
-    end
-  {Learn more}[link:classes/ActionController/Filters/ClassMethods.html]
-* Helpers for forms, dates, action links, and text
-    <%= text_field_tag "post", "title", "size" => 30 %>
-    <%= link_to "New post", :controller => "post", :action => "new" %>
-    <%= truncate(post.title, :length => 25) %>
-  {Learn more}[link:classes/ActionView/Helpers.html]
-* Layout sharing for template reuse
-    class WeblogController < ActionController::Base
-      layout "weblog_layout"
-      def hello_world
-      end
-    end
-    Layout file (called weblog_layout):
-      <html><body><%= yield %></body></html>
-    Template for hello_world action:
-      <h1>Hello world</h1>
-    Result of running hello_world action:
-      <html><body><h1>Hello world</h1></body></html>
-  {Learn more}[link:classes/ActionController/Layout/ClassMethods.html]
-* Routing makes pretty URLs incredibly easy
-    match 'clients/:client_name/:project_name/:controller/:action'
-    Accessing "/clients/37signals/basecamp/project/index" calls ProjectController#index with
-    { "client_name" => "37signals", "project_name" => "basecamp" } in `params`
-    From that action, you can write the redirect in a number of ways:
-    redirect_to(:action => "edit") =>
-      /clients/37signals/basecamp/project/edit
-    redirect_to(:client_name => "nextangle", :project_name => "rails") =>
-      /clients/nextangle/rails/project/index
-  {Learn more}[link:classes/ActionDispatch/Routing.html]
-* Easy testing of both controller and rendered template through ActionController::TestCase
-    class LoginControllerTest < ActionController::TestCase
-      def test_failing_authenticate
-        process :authenticate, :user_name => "nop", :password => ""
-        assert flash.has_key?(:alert)
-        assert_redirected_to :action => "index"
-      end
-    end
-  {Learn more}[link:classes/ActionController/TestCase.html]
-* Automated benchmarking and integrated logging
-    Started GET "/weblog" for 127.0.0.1 at Fri May 28 00:41:55
-      Processing by WeblogController#index as HTML
-    Rendered weblog/index.html.erb within layouts/application (25.7ms)
-    Completed 200 OK in 29.3ms
-    If Active Record is used as the model, you'll have the database debugging
-    as well:
-    Started POST "/posts" for 127.0.0.1 at Sat Jun 19 14:04:23
-      Processing by PostsController#create as HTML
-      Parameters: {"post"=>{"title"=>"this is good"}}
-    SQL (0.6ms) INSERT INTO posts (title) VALUES('this is good')
-    Redirected to http://example.com/posts/5
-    Completed 302 Found in 221ms (Views: 215ms | ActiveRecord: 0.6ms)
-    You specify a logger through a class method, such as:
-    ActionController::Base.logger = Logger.new("Application Log")
-    ActionController::Base.logger = Log4r::Logger.new("Application Log")
-* Caching at three levels of granularity (page, action, fragment)
-    class WeblogController < ActionController::Base
-      caches_page :show
-      caches_action :account
-      def show
-        # the output of the method will be cached as
-        # ActionController::Base.page_cache_directory + "/weblog/show/n.html"
-        # and the web server will pick it up without even hitting Rails
-      end
-      def account
-        # the output of the method will be cached in the fragment store
-        # but Rails is hit to retrieve it, so filters are run
-      end
-      def update
-        List.update(params[:list][:id], params[:list])
-        expire_page   :action => "show", :id => params[:list][:id]
-        expire_action :action => "account"
-        redirect_to   :action => "show", :id => params[:list][:id]
-      end
-    end
-  {Learn more}[link:classes/ActionController/Caching.html]
-* Powerful debugging mechanism for local requests
-    All exceptions raised on actions performed on the request of a local user
-    will be presented with a tailored debugging screen that includes exception
-    message, stack trace, request parameters, session contents, and the
-    half-finished response.
-  {Learn more}[link:classes/ActionController/Rescue.html]
-== Simple example (from outside of Rails)
-This example will implement a simple weblog system using inline templates and
-an Active Record model. So let's build that WeblogController with just a few
-methods:
-  require 'action_controller'
-  require 'post'
-  class WeblogController < ActionController::Base
-    layout "weblog/layout"
-    def index
-      @posts = Post.all
-    end
-    def show
-      @post = Post.find(params[:id])
-    end
-    def new
-      @post = Post.new
-    end
-    def create
-      @post = Post.create(params[:post])
-      redirect_to :action => "show", :id => @post.id
-    end
-  end
-  WeblogController::Base.view_paths = [ File.dirname(__FILE__) ]
-  WeblogController.process_cgi if $0 == __FILE__
-The last two lines are responsible for telling ActionController where the
-template files are located and actually running the controller on a new
-request from the web-server (e.g., Apache).
-And the templates look like this:
-  weblog/layout.html.erb:
-    <html><body>
-    <%= yield %>
-    </body></html>
-  weblog/index.html.erb:
-    <% @posts.each do |post| %>
-      <p><%= link_to(post.title, :action => "show", :id => post.id) %></p>
-    <% end %>
-  weblog/show.html.erb:
-    <p>
-      <b><%= @post.title %></b><br/>
-      <b><%= @post.content %></b>
-    </p>
-  weblog/new.html.erb:
-    <%= form "post" %>
-This simple setup will list all the posts in the system on the index page,
-which is called by accessing /weblog/. It uses the form builder for the Active
-Record model to make the new screen, which in turn hands everything over to
-the create action (that's the default target for the form builder when given a
-new model). After creating the post, it'll redirect to the show page using
-an URL such as /weblog/5 (where 5 is the id of the post).
-== Download and installation
-The latest version of Action Pack can be installed with RubyGems:
-  % [sudo] gem install actionpack
-Source code can be downloaded as part of the Rails project on GitHub
-* https://github.com/rails/rails/tree/master/actionpack
-== License
-Action Pack is released under the MIT license.
-== Support
-API documentation is at
-* http://api.rubyonrails.org
-Bug reports and feature requests can be filed with the rest for the Ruby on Rails project here:
-* https://github.com/rails/rails/issues

data/vendor/bundle/gems/actionpack-3.2.1/lib/action_controller/caching/actions.rb DELETED Viewed

@@ -1,183 +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
-        content = content.join if content.is_a?(Array)
-        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.1/lib/action_controller/metal/force_ssl.rb DELETED Viewed

@@ -1,38 +0,0 @@
-module ActionController
-  # This module provides a method which will redirect browser to use HTTPS
-  # protocol. This will ensure that user's sensitive information will be
-  # transferred safely over the internet. You _should_ always force browser
-  # to use HTTPS when you're transferring sensitive information such as
-  # user authentication, account information, or credit card information.
-  #
-  # Note that if you are really concerned about your application security,
-  # you might consider using +config.force_ssl+ in your config file instead.
-  # That will ensure all the data transferred via HTTPS protocol and prevent
-  # user from getting session hijacked when accessing the site under unsecured
-  # HTTP protocol.
-  module ForceSSL
-    extend ActiveSupport::Concern
-    include AbstractController::Callbacks
-    module ClassMethods
-      # Force the request to this particular controller or specified actions to be
-      # under HTTPS protocol.
-      #
-      # Note that this method will not be effective on development environment.
-      #
-      # ==== Options
-      # * <tt>only</tt>   - The callback should be run only for this action
-      # * <tt>except<tt>  - The callback should be run for all actions except this action
-      def force_ssl(options = {})
-        host = options.delete(:host)
-        before_filter(options) do
-          if !request.ssl? && !Rails.env.development?
-            redirect_options = {:protocol => 'https://', :status => :moved_permanently}
-            redirect_options.merge!(:host => host) if host
-            redirect_to redirect_options
-          end
-        end
-      end
-    end
-  end
-end