base_rails_app 0.0.1

data/lib/vendor/plugins/inherited_resources/lib/inherited_resources/polymorphic_helpers.rb

@@ -0,0 +1,155 @@
+module InheritedResources
+
+  # = polymorphic associations
+  #
+  # In some cases you have a resource that belongs to two different resources
+  # but not at the same time. For example, let's suppose you have File, Message
+  # and Task as resources and they are all commentable.
+  #
+  # Polymorphic associations allows you to create just one controller that will
+  # deal with each case.
+  #
+  #   class Comment < InheritedResources::Base
+  #     belongs_to :file, :message, :task, :polymorphic => true
+  #   end
+  #
+  # Your routes should be something like:
+  #
+  #   m.resources :files,    :has_many => :comments #=> /files/13/comments
+  #   m.resources :tasks,    :has_many => :comments #=> /tasks/17/comments
+  #   m.resources :messages, :has_many => :comments #=> /messages/11/comments
+  #
+  # When using polymorphic associations, you get some free helpers:
+  #
+  #   parent?         #=> true
+  #   parent_type     #=> :task
+  #   parent_class    #=> Task
+  #   parent          #=> @task
+  #
+  # This polymorphic controllers thing is a great idea by James Golick and he
+  # built it in resource_controller. Here is just a re-implementation.
+  #
+  # = optional polymorphic associations
+  #
+  # Let's take another break from ProjectsController. Let's suppose we are
+  # building a store, which sell products.
+  #
+  # On the website, we can show all products, but also products scoped to
+  # categories, brands, users. In this case case, the association is optional, and
+  # we deal with it in the following way:
+  #
+  #   class ProductsController < InheritedResources::Base
+  #     belongs_to :category, :brand, :user, :polymorphic => true, :optional => true
+  #   end
+  #
+  # This will handle all those urls properly:
+  #
+  #   /products/1
+  #   /categories/2/products/5
+  #   /brands/10/products/3
+  #   /user/13/products/11
+  #
+  # = nested polymorphic associations
+  #
+  # You can have polymorphic associations with nested resources. Let's suppose
+  # that our File, Task and Message resources in the previous example belongs to
+  # a project.
+  #
+  # This way we can have:
+  #
+  #   class CommentsController < InheritedResources::Base
+  #     belongs_to :project {
+  #       belongs_to :file, :message, :task, :polymorphic => true
+  #     }
+  #   end
+  #
+  # Or:
+  #
+  #   class CommentsController < InheritedResources::Base
+  #     nested_belongs_to :project
+  #     nested_belongs_to :file, :message, :task, :polymorphic => true
+  #   end
+  #
+  # Choose the syntax that makes more sense to you. :)
+  #
+  # Finally your routes should be something like:
+  #
+  #   map.resources :projects do |m|
+  #     m.resources :files,    :has_many => :comments #=> /projects/1/files/13/comments
+  #     m.resources :tasks,    :has_many => :comments #=> /projects/1/tasks/17/comments
+  #     m.resources :messages, :has_many => :comments #=> /projects/1/messages/11/comments
+  #   end
+  #
+  # The helpers work in the same way as above.
+  #
+  module PolymorphicHelpers
+
+    protected
+
+      # Returns the parent type. A Comments class can have :task, :file, :note
+      # as parent types.
+      #
+      def parent_type
+        @parent_type
+      end
+
+      def parent_class
+        parent.class if @parent_type
+      end
+
+      # Returns the parent object. They are also available with the instance
+      # variable name: @task, @file, @note...
+      #
+      def parent
+        instance_variable_get("@#{@parent_type}") if @parent_type
+      end
+
+      # If the polymorphic association is optional, we might not have a parent.
+      #
+      def parent?
+        if resources_configuration[:polymorphic][:optional]
+          parents_symbols.size > 1 || !@parent_type.nil?
+        else
+          true
+        end
+      end
+
+    private
+
+      # Maps parents_symbols to build association chain.
+      #
+      # If the parents_symbols find :polymorphic, it goes through the
+      # params keys to see which polymorphic parent matches the given params.
+      #
+      # When optional is given, it does not raise errors if the polymorphic
+      # params are missing.
+      #
+      def symbols_for_association_chain #:nodoc:
+        polymorphic_config = resources_configuration[:polymorphic]
+
+        parents_symbols.map do |symbol|
+          if symbol == :polymorphic
+            params_keys = params.keys
+
+            key = polymorphic_config[:symbols].find do |poly|
+              params_keys.include? resources_configuration[poly][:param].to_s
+            end
+
+            if key.nil?
+              raise ScriptError, "Could not find param for polymorphic association. The request" <<
+                                 "parameters are #{params.keys.inspect} and the polymorphic " <<
+                                 "associations are #{polymorphic_config[:symbols].inspect}." unless polymorphic_config[:optional]
+
+              nil
+            else
+              @parent_type = key.to_sym
+            end
+          else
+            symbol
+          end
+        end.compact
+      end
+
+  end
+end
+

data/lib/vendor/plugins/inherited_resources/lib/inherited_resources/singleton_helpers.rb

@@ -0,0 +1,95 @@
+module InheritedResources
+
+  # = singleton
+  #
+  # Singletons are usually used in associations which are related through has_one
+  # and belongs_to. You declare those associations like this:
+  #
+  #   class ManagersController < InheritedResources::Base
+  #     belongs_to :project, :singleton => true
+  #   end
+  #
+  # But in some cases, like an AccountsController, you have a singleton object
+  # that is not necessarily associated with another:
+  #
+  #   class AccountsController < InheritedResources::Base
+  #     defaults :singleton => true
+  #   end
+  #
+  # Besides that, you should overwrite the methods :resource and :build_resource
+  # to make it work properly:
+  #
+  #   class AccountsController < InheritedResources::Base
+  #     defaults :singleton => true
+  #
+  #     protected
+  #       def resource
+  #         @current_user.account
+  #       end
+  #
+  #       def build_resource(attributes = {})
+  #         Account.new(attributes)
+  #       end
+  #   end
+  #
+  # When you have a singleton controller, the action index is removed.
+  #
+  module SingletonHelpers
+
+    protected
+
+      # Singleton methods does not deal with collections.
+      #
+      def collection
+        nil
+      end
+
+      # Overwrites how singleton deals with resource.
+      #
+      # If you are going to overwrite it, you should notice that the
+      # end_of_association_chain here is not the same as in default belongs_to.
+      #
+      #   class TasksController < InheritedResources::Base
+      #     belongs_to :project
+      #   end
+      #
+      # In this case, the association chain would be:
+      #
+      #   Project.find(params[:project_id]).tasks
+      #
+      # So you would just have to call find(:all) at the end of association
+      # chain. And this is what happened.
+      #
+      # In singleton controllers:
+      #
+      #   class ManagersController < InheritedResources::Base
+      #     belongs_to :project, :singleton => true
+      #   end
+      #
+      # The association chain will be:
+      #
+      #   Project.find(params[:project_id])
+      #
+      # So we have to call manager on it, not find.
+      #
+      def resource
+        get_resource_ivar || set_resource_ivar(end_of_association_chain.send(resource_instance_name))
+      end
+
+    private
+
+      # Returns the appropriated method to build the resource.
+      #
+      def method_for_association_build #:nodoc:
+        :"build_#{resource_instance_name}"
+      end
+
+      # Sets the method_for_association_chain to nil. See <tt>resource</tt>
+      # above for more information.
+      #
+      def method_for_association_chain #:nodoc:
+        nil
+      end
+
+  end
+end

data/lib/vendor/plugins/inherited_resources/lib/inherited_resources/url_helpers.rb

@@ -0,0 +1,179 @@
+module InheritedResources
+  # = URLHelpers
+  #
+  # When you use InheritedResources it creates some UrlHelpers for you.
+  # And they handle everything for you.
+  #
+  #  # /posts/1/comments
+  #  resource_url          # => /posts/1/comments/#{@comment.to_param}
+  #  resource_url(comment) # => /posts/1/comments/#{comment.to_param}
+  #  new_resource_url      # => /posts/1/comments/new
+  #  edit_resource_url     # => /posts/1/comments/#{@comment.to_param}/edit
+  #  collection_url        # => /posts/1/comments
+  #  parent_url            # => /posts/1
+  #
+  #  # /projects/1/tasks
+  #  resource_url          # => /projects/1/tasks/#{@task.to_param}
+  #  resource_url(task)    # => /projects/1/tasks/#{task.to_param}
+  #  new_resource_url      # => /projects/1/tasks/new
+  #  edit_resource_url     # => /projects/1/tasks/#{@task.to_param}/edit
+  #  collection_url        # => /projects/1/tasks
+  #  parent_url            # => /projects/1
+  #
+  #  # /users
+  #  resource_url          # => /users/#{@user.to_param}
+  #  resource_url(user)    # => /users/#{user.to_param}
+  #  new_resource_url      # => /users/new
+  #  edit_resource_url     # => /users/#{@user.to_param}/edit
+  #  collection_url        # => /users
+  #  parent_url            # => /
+  #
+  # The nice thing is that those urls are not guessed during runtime. They are
+  # all created when you inherit.
+  #
+  module UrlHelpers
+
+    # This method hard code url helpers in the class.
+    #
+    # We are doing this because is cheaper than guessing them when our action
+    # is being processed (and even more cheaper when we are using nested
+    # resources).
+    #
+    # When we are using polymorphic associations, those helpers rely on 
+    # polymorphic_url Rails helper.
+    #
+    def create_resources_url_helpers!
+      resource_segments, resource_ivars = [], []
+      resource_config = self.resources_configuration[:self]
+
+      singleton   = self.resources_configuration[:self][:singleton]
+      polymorphic = self.parents_symbols.include?(:polymorphic)
+
+      # Add route_prefix if any.
+      unless resource_config[:route_prefix].blank?
+        if polymorphic
+          resource_ivars << resource_config[:route_prefix].to_s.inspect
+        else
+          resource_segments << resource_config[:route_prefix]
+        end
+      end
+
+      # Deal with belongs_to associations and polymorphic associations.
+      # Remember that we don't have to build the segments in polymorphic cases,
+      # because the url will be polymorphic_url.
+      #
+      self.parents_symbols.each do |symbol|
+        if symbol == :polymorphic
+          resource_ivars << :parent
+        else
+          config = self.resources_configuration[symbol]
+          resource_segments << config[:route_name]
+          resource_ivars    << :"@#{config[:instance_name]}"
+        end
+      end
+
+      collection_ivars    = resource_ivars.dup
+      collection_segments = resource_segments.dup
+
+      # Generate parent url before we add resource instances.
+      generate_url_and_path_helpers nil, :parent, resource_segments, resource_ivars
+
+      # This is the default route configuration, later we have to deal with
+      # exception from polymorphic and singleton cases.
+      #
+      collection_segments << resource_config[:route_collection_name]
+      resource_segments   << resource_config[:route_instance_name]
+      resource_ivars      << :"@#{resource_config[:instance_name]}"
+
+      # In singleton cases, we do not send the current element instance variable
+      # because the id is not in the URL. For example, we should call:
+      #
+      #   project_manager_url(@project)
+      #
+      # Instead of:
+      #
+      #   project_manager_url(@project, @manager)
+      #
+      # Another exception in singleton cases is that collection url does not
+      # exist. In such cases, we create the parent collection url. So in the
+      # manager case above, the collection url will be:
+      #
+      #    project_url(@project)
+      #
+      # If the singleton does not have a parent, it will default to root_url.
+      #
+      # Finally, polymorphic cases we have to give hints to the polymorphic url
+      # builder. This works by attaching new ivars as symbols or records.
+      #
+      if singleton
+        collection_segments.pop
+        resource_ivars.pop
+
+        if polymorphic
+          resource_ivars << resource_config[:instance_name].inspect
+          new_ivars       = resource_ivars
+        end
+      elsif polymorphic
+        collection_ivars << '(@_resource_class_new ||= resource_class.new)'
+      end
+
+      generate_url_and_path_helpers nil,   :collection, collection_segments, collection_ivars
+      generate_url_and_path_helpers :new,  :resource,   resource_segments,   new_ivars || collection_ivars
+      generate_url_and_path_helpers nil,   :resource,   resource_segments,   resource_ivars
+      generate_url_and_path_helpers :edit, :resource,   resource_segments,   resource_ivars
+    end
+
+    def generate_url_and_path_helpers(prefix, name, resource_segments, resource_ivars) #:nodoc:
+      ivars = resource_ivars.dup
+
+      singleton   = self.resources_configuration[:self][:singleton]
+      polymorphic = self.parents_symbols.include?(:polymorphic)
+
+      # If it's not a singleton, ivars are not empty, not a collection or
+      # not a "new" named route, we can pass a resource as argument.
+      #
+      unless (singleton && name != :parent) || ivars.empty? || name == :collection || prefix == :new
+        ivars.push "(given_args.first || #{ivars.pop})"
+      end
+
+      # In collection in polymorphic cases, allow an argument to be given as a
+      # replacemente for the parent.
+      #
+      if name == :collection && polymorphic
+        index = ivars.index(:parent)
+        ivars.insert index, "(given_args.first || parent)"
+        ivars.delete(:parent)
+      end
+
+      # When polymorphic is true, the segments must be replace by :polymorphic
+      # and ivars should be gathered into an array, which is compacted when
+      # optional.
+      #
+      if polymorphic
+        segments = :polymorphic
+        ivars    = "[#{ivars.join(', ')}]"
+        ivars   << '.compact' if self.resources_configuration[:polymorphic][:optional]
+      else
+        segments = resource_segments.empty? ? 'root' : resource_segments.join('_')
+        ivars    = ivars.join(', ')
+      end
+
+      prefix = prefix ? "#{prefix}_" : ''
+      ivars << (ivars.empty? ? 'given_options' : ', given_options')
+
+      class_eval <<-URL_HELPERS, __FILE__, __LINE__
+        protected
+          def #{prefix}#{name}_path(*given_args)
+            given_options = given_args.extract_options!
+            #{prefix}#{segments}_path(#{ivars})
+          end
+
+          def #{prefix}#{name}_url(*given_args)
+            given_options = given_args.extract_options!
+            #{prefix}#{segments}_url(#{ivars})
+          end
+      URL_HELPERS
+    end
+
+  end
+end

data/lib/vendor/plugins/inherited_resources/test/aliases_test.rb

@@ -0,0 +1,139 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Student;
+  def self.human_name; 'Student'; end
+end
+
+class ApplicationController < ActionController::Base
+  include InheritedResources::DSL
+end
+
+class StudentsController < ApplicationController
+  inherit_resources
+  respond_to :html, :xml
+
+  def edit
+    edit! do |format|
+      format.xml { render :text => 'Render XML' }
+    end
+  end
+
+  def new
+    @something = 'magical'
+    new!
+  end
+
+  create!(:location => "http://test.host/") do |success, failure|
+    success.html { render :text => "I won't redirect!" }
+    failure.xml { render :text => "I shouldn't be rendered" }
+  end
+
+  update! do |success, failure|
+    success.html { redirect_to(resource_url) }
+    failure.html { render :text => "I won't render!" }
+  end
+
+  destroy! do |format|
+    format.html { render :text => "Destroyed!" }
+  end
+end
+
+class AliasesTest < ActionController::TestCase
+  tests StudentsController
+
+  def test_assignments_before_calling_alias
+    Student.stubs(:new).returns(mock_student)
+    get :new
+    assert_response :success
+    assert_equal 'magical', assigns(:something)
+  end
+
+  def test_controller_should_render_new
+    Student.stubs(:new).returns(mock_student)
+    get :new
+    assert_response :success
+    assert_equal 'New HTML', @response.body.strip
+  end
+
+  def test_expose_the_resquested_user_on_edit
+    Student.expects(:find).with('42').returns(mock_student)
+    get :edit, :id => '42'
+    assert_equal mock_student, assigns(:student)
+    assert_response :success
+  end
+
+  def test_controller_should_render_edit
+    Student.stubs(:find).returns(mock_student)
+    get :edit
+    assert_response :success
+    assert_equal 'Edit HTML', @response.body.strip
+  end
+
+  def test_render_xml_when_it_is_given_as_a_block
+    @request.accept = 'application/xml'
+    Student.stubs(:find).returns(mock_student)
+    get :edit
+    assert_response :success
+    assert_equal 'Render XML', @response.body
+  end
+
+  def test_is_not_redirected_on_create_with_success_if_success_block_is_given
+    Student.stubs(:new).returns(mock_student(:save => true))
+    @controller.stubs(:resource_url).returns('http://test.host/')
+    post :create
+    assert_response :success
+    assert_equal "I won't redirect!", @response.body
+  end
+
+  def test_dumb_responder_quietly_receives_everything_on_failure
+    @request.accept = 'text/html'
+    Student.stubs(:new).returns(mock_student(:save => false, :errors => {:some => :error}))
+    @controller.stubs(:resource_url).returns('http://test.host/')
+    post :create
+    assert_response :success
+    assert_equal "New HTML", @response.body.strip
+  end
+
+  def test_html_is_the_default_when_only_xml_is_overwriten
+    @request.accept = '*/*'
+    Student.stubs(:new).returns(mock_student(:save => false, :errors => {:some => :error}))
+    @controller.stubs(:resource_url).returns('http://test.host/')
+    post :create
+    assert_response :success
+    assert_equal "New HTML", @response.body.strip
+  end
+
+  def test_wont_render_edit_template_on_update_with_failure_if_failure_block_is_given
+    Student.stubs(:find).returns(mock_student(:update_attributes => false))
+    put :update
+    assert_response :success
+    assert_equal "I won't render!", @response.body
+  end
+
+  def test_dumb_responder_quietly_receives_everything_on_success
+    Student.stubs(:find).returns(mock_student(:update_attributes => true))
+    @controller.stubs(:resource_url).returns('http://test.host/')
+    put :update, :id => '42', :student => {:these => 'params'}
+    assert_equal mock_student, assigns(:student)
+  end
+
+  def test_block_is_called_when_student_is_destroyed
+    Student.stubs(:find).returns(mock_student(:destroy => true))
+    delete :destroy
+    assert_response :success
+    assert_equal "Destroyed!", @response.body
+  end
+
+  def test_options_are_used_in_respond_with
+    @request.accept = "application/xml"
+    Student.stubs(:new).returns(mock_student(:save => true, :to_xml => "XML"))
+    post :create
+    assert_equal "http://test.host/", @response.location
+  end
+
+  protected
+    def mock_student(stubs={})
+      @mock_student ||= mock(stubs)
+    end
+end
+