make_resourceful_rails2 1.0.1

data/lib/resourceful/default/callbacks.rb

@@ -0,0 +1,51 @@
+require 'resourceful/builder'
+
+module Resourceful
+  module Default
+    # This module is mostly meant to be used by the make_resourceful default actions.
+    # It provides various methods that declare where callbacks set in the +make_resourceful+ block,
+    # like Builder#before and Builder#response_for,
+    # should be called.
+    module Callbacks
+      # Calls any +before+ callbacks set in the +make_resourceful+ block for the given event.
+      def before(event)
+        resourceful_fire(:before, event.to_sym)
+      end
+
+      # Calls any +after+ callbacks set in the +make_resourceful+ block for the given event.
+      def after(event)
+        resourceful_fire(:after, event.to_sym)
+      end
+
+      # Calls any +response_for+ callbacks set in the +make_resourceful+ block for the given event.
+      # Note that these aren't called directly,
+      # but instead passed along to Rails' respond_to method.
+      def response_for(event)
+        if responses = self.class.resourceful_responses[event.to_sym]
+          respond_to do |format|
+            responses.each do |key, value|
+              format.send(key, &scope(value))
+            end
+          end
+        end
+      end
+
+      # Returns a block identical to the given block,
+      # but in the context of the current controller.
+      # The returned block accepts no arguments,
+      # even if the given block accepted them.
+      def scope(block)
+        proc do
+          instance_eval(&(block || proc {}))
+        end
+      end
+
+      private
+
+      def resourceful_fire(type, name)
+        callbacks = self.class.resourceful_callbacks[type][name] || []
+        callbacks.each { |callback| scope(callback).call }
+      end
+    end
+  end
+end

data/lib/resourceful/default/responses.rb

@@ -0,0 +1,118 @@
+module Resourceful
+  module Default
+    module Responses
+      # Sets the default flash message.
+      # This message can be overridden by passing in
+      # an HTTP parameter of the form "_flash[type]" via POST or GET.
+      #
+      # You can use this to easily have multiple forms
+      # post to the same create/edit/destroy actions
+      # but display different flash notices -
+      # without modifying the controller code at all.
+      #
+      # By default, the flash types are +notice+ when the database operation completes successfully
+      # and +error+ when it fails.
+      #
+      #--
+      # TODO: Move this out of here
+      #++
+      def set_default_flash(type, message)
+        flash[type] ||= (params[:_flash] && params[:_flash][type]) || message
+      end
+
+      # Sets the default redirect
+      # (the argument passed to +redirect_to+).
+      # This message can be overridden by passing in
+      # an HTTP parameter of the form "_redirect_on[status]" via POST or GET.
+      #
+      # You can use this to easily have multiple forms
+      # post to the same create/edit/destroy actions
+      # but redirect to different URLs -
+      # without modifying the controller code at all.
+      #
+      # By default, the redirect statuses are +success+ when the database operation completes successfully
+      # and +failure+ when it fails.
+      # Use the <tt>:status</tt> option to specify which status to run the redirect for.
+      # For example:
+      #
+      #   set_default_redirect "/posts", :status => :failure
+      #
+      # This will run <tt>redirect_to params[:_redirect_on][:failure]</tt> if the parameter exists,
+      # or <tt>redirect_to "/posts"</tt> otherwise.
+      #
+      #--
+      # TODO: Move this out of here
+      #++
+      def set_default_redirect(to, options = {})
+        status = options[:status] || :success
+        redirect_to (params[:_redirect_on] && params[:_redirect_on][status]) || to
+      end
+
+      # This method is automatically run when this module is included in Resourceful::Base.
+      # It sets up the default responses for the default actions.
+      def self.included(base)
+        base.made_resourceful do
+          response_for(:show, :index, :edit, :new) do |format|
+            format.html
+            format.js
+          end
+
+          response_for(:show_fails) do |format|
+            not_found = Proc.new { render :text => I18n.t('make_resourceful.show.fails', :default => "No item found"), :status => 404 }
+            format.html &not_found
+            format.js &not_found
+            format.xml &not_found
+          end
+
+          response_for(:create) do |format|
+            format.html do
+              set_default_flash :notice, I18n.t('make_resourceful.create.success', :default => "Create successful!")
+              set_default_redirect object_path
+            end
+            format.js
+          end
+          
+          response_for(:create_fails) do |format|
+            format.html do
+              set_default_flash :error, I18n.t('make_resourceful.create.fails', :default => "There was a problem!")
+              render :action => :new, :status => 422
+            end
+            format.js
+          end
+        
+          response_for(:update) do |format|
+            format.html do
+              set_default_flash :notice, I18n.t('make_resourceful.update.success', :default => "Save successful!")
+              set_default_redirect object_path
+            end
+            format.js
+          end
+          
+          response_for(:update_fails) do |format|
+            format.html do
+              set_default_flash :error, I18n.t('make_resourceful.update.fails', :default => "There was a problem saving!")
+              render :action => :edit, :status => 422
+            end
+            format.js
+          end
+          
+          response_for(:destroy) do |format|
+            format.html do
+              set_default_flash :notice, I18n.t('make_resourceful.destroy.success', :default => "Record deleted!")
+              set_default_redirect objects_path
+            end
+            format.js
+          end
+          
+          response_for(:destroy_fails) do |format|
+            format.html do
+              set_default_flash :error, I18n.t('make_resourceful.destroy.fails', :default => "There was a problem deleting!")
+              set_default_redirect :back, :status => :failure
+            end
+            format.js
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resourceful/default/urls.rb

@@ -0,0 +1,136 @@
+module Resourceful
+  module Default
+    # This file contains various methods to make URL helpers less painful.
+    # They provide methods analogous to the standard foo_url and foo_path helpers.
+    # However, they use make_resourceful's knowledge of the structure of the controller
+    # to allow you to avoid figuring out which method to call and which parent objects it should be passed.
+    module URLs
+      # This returns the path for the given object,
+      # by default current_object[link:classes/Resourceful/Default/Accessors.html#M000012].
+      # For example, in HatsController the following are equivalent:
+      #
+      #   object_path    #=> "/hats/12"
+      #   hat_path(@hat) #=> "/hats/12"
+      # 
+      def object_path(object = current_object); object_route(object, 'path'); end
+      # Same as object_path, but with the protocol and hostname.
+      def object_url (object = current_object); object_route(object, 'url');  end
+
+      # This is the same as object_path,
+      # unless a parent exists.
+      # Then it returns the nested path for the object.
+      # For example, in HatsController where Person has_many :hats and <tt>params[:person_id] == 42</tt>,
+      # the following are equivalent:
+      #
+      #   nested_object_path             #=> "/person/42/hats/12"
+      #   person_hat_path(@person, @hat) #=> "/person/42/hats/12"
+      # 
+      def nested_object_path(object = current_object); nested_object_route(object, 'path'); end
+      # Same as nested_object_path, but with the protocol and hostname.
+      def nested_object_url (object = current_object); nested_object_route(object, 'url');  end
+
+      # This returns the path for the edit action for the given object,
+      # by default current_object[link:classes/Resourceful/Default/Accessors.html#M000012].
+      # For example, in HatsController the following are equivalent:
+      #
+      #   edit_object_path                    #=> "/hats/12/edit"
+      #   edit_person_hat_path(@person, @hat) #=> "/hats/12/edit"
+      # 
+      def edit_object_path(object = current_object); edit_object_route(object, 'path'); end
+      # Same as edit_object_path, but with the protocol and hostname.
+      def edit_object_url (object = current_object); edit_object_route(object, 'url');  end
+
+      # This returns the path for the collection of the current controller.
+      # For example, in HatsController where Person has_many :hats and <tt>params[:person_id] == 42</tt>,
+      # the following are equivalent:
+      #
+      #   objects_path              #=> "/people/42/hats"
+      #   person_hats_path(@person) #=> "/people/42/hats"
+      # 
+      def objects_path; objects_route('path'); end
+      # Same as objects_path, but with the protocol and hostname.
+      def objects_url ; objects_route('url');  end
+
+      # This returns the path for the new action for the current controller.
+      # For example, in HatsController where Person has_many :hats and <tt>params[:person_id] == 42</tt>,
+      # the following are equivalent:
+      #
+      #   new_object_path              #=> "/people/42/hats/new"
+      #   new_person_hat_path(@person) #=> "/people/42/hats/new"
+      # 
+      def new_object_path; new_object_route('path'); end
+      # Same as new_object_path, but with the protocol and hostname.
+      def new_object_url ; new_object_route('url');  end
+
+      # This returns the path for the parent object.
+      # 
+      def parent_path(object = parent_object)
+        instance_route(parent_class_name.underscore, object, 'path')
+      end
+      # Same as parent_path, but with the protocol and hostname.
+      def parent_url(object = parent_object)
+        instance_route(parent_class_name.underscore, object, 'url')
+      end
+
+      # This prefix is added to the Rails URL helper names
+      # before they're called.
+      # By default, it's the underscored list of namespaces of the current controller,
+      # or nil if there are no namespaces defined.
+      # However, it can be overridden if another prefix is needed.
+      # Note that if this is overridden,
+      # the new method should return a string ending in an underscore.
+      #
+      # For example, in Admin::Content::PagesController:
+      #
+      #   url_helper_prefix #=> "admin_content_"
+      #
+      # Then object_path is the same as <tt>admin_content_page_path(current_object)</tt>.
+      def url_helper_prefix
+        namespaces.empty? ? nil : "#{namespaces.join('_')}_"
+      end
+
+      # This prefix is added to the Rails URL helper names
+      # for the make_resourceful collection URL helpers,
+      # objects_path and new_object_path.
+      # By default, it's the parent name followed by an underscore if a parent
+      # is given, and the empty string otherwise.
+      #
+      # See also url_helper_prefix.
+      def collection_url_prefix
+        parent? ? "#{parent_class_name.underscore}_" : ''
+      end
+
+      private
+
+      def object_route(object, type)
+        instance_route(current_model_name.underscore, object, type)
+      end
+
+      def nested_object_route(object, type)
+        return object_route(object, type) unless parent?
+        send("#{url_helper_prefix}#{parent_class_name.underscore}_#{current_model_name.underscore}_#{type}", parent_object, object)
+      end
+
+      def edit_object_route(object, type)
+        instance_route(current_model_name.underscore, object, type, "edit")
+      end
+
+      def objects_route(type)
+        collection_route(current_model_name.pluralize.underscore, type)
+      end
+
+      def new_object_route(type)
+        collection_route(current_model_name.underscore, type, "new")
+      end
+
+      def instance_route(name, object, type, action = nil)
+        send("#{action ? action + '_' : ''}#{url_helper_prefix}#{collection_url_prefix unless shallow?}#{name}_#{type}", *(parent? && !shallow? ? [parent_object, object] : [object]))
+      end
+
+      def collection_route(name, type, action = nil)
+        send("#{action ? action + '_' : ''}#{url_helper_prefix}#{collection_url_prefix}#{name}_#{type}",
+             *(parent? ? [parent_object] : []))
+      end
+    end
+  end
+end

data/lib/resourceful/generators/resourceful_scaffold/resourceful_scaffold_generator.rb

@@ -0,0 +1,87 @@
+class ResourcefulScaffoldGenerator < Rails::Generators::Base
+  attr_reader   :controller_class_path,
+                :controller_file_path,
+                :controller_class_nesting,
+                :controller_class_nesting_depth,
+                :controller_class_name,
+                :controller_underscore_name,
+                :controller_plural_name
+  alias_method  :controller_file_name,  :controller_underscore_name
+  alias_method  :controller_table_name, :controller_plural_name
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+
+    base_name, @controller_class_path, @controller_file_path, @controller_class_nesting, @controller_class_nesting_depth = extract_modules(@name.pluralize)
+    @controller_class_name_without_nesting, @controller_underscore_name, @controller_plural_name = inflect_names(base_name)
+
+    if @controller_class_nesting.empty?
+      @controller_class_name = @controller_class_name_without_nesting
+    else
+      @controller_class_name = "#{@controller_class_nesting}::#{@controller_class_name_without_nesting}"
+    end
+  end
+  
+  def manifest
+    record do |m|
+      # Check for class naming collisions.
+      m.class_collisions(controller_class_path, "#{controller_class_name}Controller", "#{controller_class_name}Helper")
+      m.class_collisions(class_path, "#{class_name}")
+
+      # Controller, helper, views, and test directories.
+      m.directory(File.join('app/models', class_path))
+      m.directory(File.join('app/controllers', controller_class_path))
+      m.directory(File.join('app/helpers', controller_class_path))
+      m.directory(File.join('app/views', controller_class_path, controller_file_name))
+      m.directory(File.join('test/functional', controller_class_path))
+      m.directory(File.join('test/unit', class_path))
+      m.directory(File.join('test/fixtures', class_path))
+
+      # Views
+      for action in scaffold_views
+        m.template("view_#{action}.haml", File.join('app/views', controller_class_path, controller_file_name, "#{action}.html.haml"))
+      end
+      m.template('view_partial.haml', File.join('app/views', controller_class_path, controller_file_name, "_#{singular_name}.html.haml"))
+
+      # Helper
+      m.template('helper.rb', File.join('app/helpers', controller_class_path, "#{controller_file_name}_helper.rb"))
+
+      # Model
+      m.template('model.rb', File.join('app/models', class_path, "#{file_name}.rb"))
+
+      unless options[:skip_migration]
+        m.migration_template('migration.rb', 'db/migrate', 
+          :assigns => {
+            :migration_name => "Create#{class_name.pluralize.gsub(/::/, '')}",
+            :attributes     => attributes
+          },
+          :migration_file_name => "create_#{file_path.gsub(/\//, '_').pluralize}")
+      end
+
+      # Controller
+      m.template('controller.rb', File.join('app/controllers', controller_class_path, "#{controller_file_name}_controller.rb"))      
+
+      # Tests
+      m.template('functional_test.rb', File.join('test/functional', controller_class_path, "#{controller_file_name}_controller_test.rb"))
+      m.template('unit_test.rb',       File.join('test/unit', class_path, "#{file_name}_test.rb"))
+      m.template('fixtures.yml',       File.join('test/fixtures', "#{table_name}.yml"))
+
+      # Route
+      m.route_resources controller_file_name
+    end
+  end
+
+  protected
+  
+  def banner
+    "Usage: #{$0} resourcefulscaffold ModelName [field:type, field:type]"
+  end
+
+  def scaffold_views
+    %w[ index show new edit _form ]
+  end
+
+  def model_name 
+    class_name.demodulize
+  end
+end

data/lib/resourceful/generators/resourceful_scaffold/templates/controller.rb

@@ -0,0 +1,5 @@
+class <%= controller_class_name %>Controller < ApplicationController
+  make_resourceful do
+    actions :all
+  end
+end

data/lib/resourceful/generators/resourceful_scaffold/templates/fixtures.yml

@@ -0,0 +1,10 @@
+one:
+  id: 1
+<% for attribute in attributes -%>
+  <%= attribute.name %>: <%= attribute.default %>
+<% end -%>
+two:
+  id: 2
+<% for attribute in attributes -%>
+  <%= attribute.name %>: <%= attribute.default %>
+<% end -%>

data/lib/resourceful/generators/resourceful_scaffold/templates/functional_test.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '<%= '/..' * controller_class_nesting_depth %>/../test_helper'
+require '<%= controller_file_path %>_controller'
+
+# Re-raise errors caught by the controller.
+class <%= controller_class_name %>Controller; def rescue_action(e) raise e end; end
+
+class <%= controller_class_name %>ControllerTest < ActionController::TestCase
+
+  def test_should_get_index
+    get :index
+    assert_response :success
+    assert assigns(:<%= table_name %>)
+  end
+
+  def test_should_get_new
+    get :new
+    assert_response :success
+  end
+
+  def test_should_create_<%= file_name %>
+    old_count = <%= class_name %>.count
+    post :create, :<%= file_name %> => { }
+    assert_equal old_count + 1, <%= class_name %>.count
+
+    assert_redirected_to <%= file_name %>_path(assigns(:<%= file_name %>))
+  end
+
+  def test_should_show_<%= file_name %>
+    get :show, :id => 1
+    assert_response :success
+  end
+
+  def test_should_get_edit
+    get :edit, :id => 1
+    assert_response :success
+  end
+
+  def test_should_update_<%= file_name %>
+    put :update, :id => 1, :<%= file_name %> => { }
+    assert_redirected_to <%= file_name %>_path(assigns(:<%= file_name %>))
+  end
+
+  def test_should_destroy_<%= file_name %>
+    old_count = <%= class_name %>.count
+    delete :destroy, :id => 1
+    assert_equal old_count-1, <%= class_name %>.count
+
+    assert_redirected_to <%= table_name %>_path
+  end
+end