make_resourceful_rails2 1.0.1

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

@@ -0,0 +1,2 @@
+module <%= controller_class_name %>Helper
+end

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

@@ -0,0 +1,13 @@
+class <%= migration_name %> < ActiveRecord::Migration
+  def self.up
+    create_table :<%= table_name %>, :force => true do |t|
+<% for attribute in attributes -%>
+      t.column :<%= attribute.name %>, :<%= attribute.type %>
+<% end -%>
+    end
+  end
+
+  def self.down
+    drop_table :<%= table_name %>
+  end
+end

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

@@ -0,0 +1,2 @@
+class <%= class_name %> < ActiveRecord::Base
+end

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

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '<%= '/..' * class_nesting_depth %>/../test_helper'
+
+class <%= class_name %>Test < Test::Unit::TestCase
+  def test_truth
+    assert true
+  end
+end

data/lib/resourceful/generators/resourceful_scaffold/templates/view__form.haml

@@ -0,0 +1,5 @@
+<%- for attribute in attributes -%>
+%p
+  %label{:for => "<%= singular_name %>_<%= attribute.name %>"} <%= attribute.column.human_name %>:
+  = f.<%= attribute.field_type %> :<%= attribute.name %>
+<% end -%>

data/lib/resourceful/generators/resourceful_scaffold/templates/view_edit.haml

@@ -0,0 +1,11 @@
+%h1 Editing <%= singular_name %>
+
+= error_messages_for :<%= singular_name %>
+
+= form_for(:<%= singular_name %>, :url => object_url, :html => { :method => :put }) do |f|
+  = render :partial => "form", :locals => {:f => f}
+  %p= submit_tag "Update"
+
+= link_to 'Show', object_path
+|
+= link_to 'Back', objects_path

data/lib/resourceful/generators/resourceful_scaffold/templates/view_index.haml

@@ -0,0 +1,5 @@
+%h1 Listing <%= plural_name %>
+
+= render :partial => '<%= singular_name %>', :collection => current_objects
+
+= link_to 'New <%= singular_name %>', new_object_path 

data/lib/resourceful/generators/resourceful_scaffold/templates/view_new.haml

@@ -0,0 +1,9 @@
+%h1 Creating <%= singular_name %>
+
+= error_messages_for :<%= singular_name %>
+
+= form_for(:<%= singular_name %>, :url => objects_url) do |f|
+  = render :partial => "form", :locals => {:f => f}
+  %p= submit_tag "Create"
+
+= link_to 'Back', objects_path

data/lib/resourceful/generators/resourceful_scaffold/templates/view_partial.haml

@@ -0,0 +1,12 @@
+%div[<%= singular_name %>]
+<% for attribute in attributes -%>
+  %p.<%= attribute.name %>
+    %strong <%= attribute.column.human_name %>
+    = h <%= singular_name %>.<%= attribute.name %>
+<% end -%>
+
+  = link_to 'Show', object_path(<%= singular_name %>)
+  |
+  = link_to 'Edit', edit_object_path(<%= singular_name %>)
+  |
+  = link_to 'Destroy', object_path(<%= singular_name %>), :confirm => 'Really destroy <%= singular_name %>?', :method => :delete

data/lib/resourceful/generators/resourceful_scaffold/templates/view_show.haml

@@ -0,0 +1,14 @@
+%h1 Viewing <%= singular_name %>
+
+%div[current_object]
+<% for attribute in attributes -%>
+  %p.<%= attribute.name %>
+    %strong <%= attribute.column.human_name %>
+    = h current_object.<%= attribute.name %>
+<% end -%>
+
+= link_to 'Edit', edit_object_path
+|
+= link_to 'Destroy', object_path, :confirm => 'Really destroy <%= singular_name %>?', :method => :delete
+|
+= link_to 'Back', objects_path

data/lib/resourceful/maker.rb

@@ -0,0 +1,92 @@
+require 'resourceful/builder'
+require 'resourceful/base'
+
+module Resourceful
+  # This module is extended by the ActionController::Base class object.
+  # It provides the actual +make_resourceful+ method
+  # and sets up the controller so that everything will work.
+  module Maker
+    # Called automatically on ActionController::Base.
+    # Initializes various inheritable attributes.
+    def self.extended(base)
+      base.class_attribute :resourceful_callbacks
+      base.class_attribute :resourceful_responses
+      base.class_attribute :parents
+      base.class_attribute :shallow_parent
+      base.class_attribute :model_namespace
+      base.class_attribute :made_resourceful
+      
+      base.resourceful_callbacks = {}
+      base.resourceful_responses = {}
+      base.parents               = []
+      base.model_namespace       = nil
+      base.made_resourceful      = false
+    end
+
+    # :call-seq:
+    #   make_resourceful(options = {}) { ... }
+    #
+    # This is the central method, and namesake, of make_resourceful.
+    # It takes a block and evaluates it in the context of a Builder,
+    # allowing the controller to be customized extensively.
+    #
+    # See Resourceful::Builder for documentation on the methods available
+    # in the context of the block.
+    #
+    # The only option currently available is <tt>:include</tt>.
+    # It takes an object that responds to to_proc
+    # (or an array of such objects)
+    # and evaluates that proc in the same context as the block.
+    # For example:
+    #
+    #   make_resourceful :include => proc { actions :all } do
+    #     before :show do
+    #       current_object.current_user = current_user
+    #     end
+    #   end
+    #
+    # This is the same as:
+    #
+    #   make_resourceful do
+    #     actions :all
+    #     before :show do
+    #       current_object.current_user = current_user
+    #     end
+    #   end
+    # 
+    def make_resourceful(options = {}, &block)
+      # :stopdoc:
+      include Resourceful::Base
+      # :startdoc:
+
+      builder = Resourceful::Builder.new(self)
+      unless builder.inherited?
+        Resourceful::Base.made_resourceful.each { |proc| builder.instance_eval(&proc) }
+      end
+      Array(options[:include]).each { |proc| builder.instance_eval(&proc) }
+      builder.instance_eval(&block)
+
+      builder.apply
+
+      add_helpers
+    end
+
+    # Returns whether or not make_resourceful has been called
+    # on this controller or any controllers it inherits from.
+    def made_resourceful?
+      self.class.made_resourceful
+    end
+
+    private
+
+    def add_helpers
+      helper_method(:object_path, :objects_path, :new_object_path, :edit_object_path,
+                    :object_url, :objects_url, :new_object_url, :edit_object_url,
+                    :parent_path, :parent_url,
+                    :nested_object_path, :nested_object_url,
+                    :current_objects, :current_object, :current_model, :current_model_name,
+                    :namespaces, :instance_variable_name, :parent_names, :parent_name,
+                    :parent?, :parent_model, :parent_object, :save_succeeded?)
+    end
+  end
+end

data/lib/resourceful/response.rb

@@ -0,0 +1,33 @@
+module Resourceful
+  # This is the class of the object passed to the Builder#response_for method.
+  # It shouldn't be used by users.
+  #
+  # The Response collects format procs
+  # and returns them with the format method,
+  # in the order they were given.
+  # For example:
+  #
+  #   response.html { redirect_to '/' }
+  #   response.xml { render :xml => current_object.to_xml }
+  #   response.js
+  #   response.formats #=> [[:html, #<Proc>], [:xml, #<Proc>], [:js, #<Proc>]]
+  #
+  # Note that the <tt>:js</tt> response is the empty proc -
+  # the same as <tt>proc {}</tt>.
+  class Response # :nodoc:
+    # Returns a list of pairs of formats and procs
+    # representing the formats passed to the response object.
+    # See class description.
+    attr :formats
+
+    # Returns a new Response with no format data.
+    def initialize
+      @formats = []
+    end
+
+    # Used to dispatch the individual format methods.
+    def method_missing(name, &block)
+      @formats.push([name, block || proc {}]) unless @formats.any? {|n,b| n == name}
+    end
+  end
+end

data/lib/resourceful/serialize.rb

@@ -0,0 +1,185 @@
+require 'resourceful/builder'
+
+module Resourceful
+  # This module contains mixin modules
+  # used to implement the object serialization
+  # used for the Builder#publish method.
+  # They can also be used to get serialized representations of objects
+  # in other contexts.
+  #
+  # Serialization makes use of duck typing.
+  # Each class that can be serialized
+  # (just Array and ActiveRecord::Base by default)
+  # implements the +serialize+ and +to_serializable+ methods.
+  # These methods are implemented differently by the different classes,
+  # but the semantics of the implementations are consistent,
+  # so they can be used consistently.
+  #
+  # +to_serializable+ returns an object that can be directly serialized
+  # with a call to +to_xml+, +to_yaml+, or +to_json+.
+  # This object is either a hash or an array,
+  # and all the elements are either values, like strings and integers,
+  # or other serializable objects.
+  # This is useful for getting a model into a simple data structure format.
+  # The +attributes+ argument uses the same semantics
+  # as the <tt>:attributes</tt> option for Builder#publish.
+  # For example:
+  #
+  #   c = Cake.new(:flavor => 'chocolate', :text => 'Happy birthday, Chris!')
+  #   c.recipient = User.new(:name => 'Chris', :password => 'not very secure')
+  #   c.to_serializable [
+  #       :flavor, :text,
+  #       :recipient => :name
+  #     ]
+  #
+  # This would return the Ruby hash
+  #
+  #   { :flavor => 'chocolate', :text => 'Happy birthday, Chris!',
+  #     :user => {:name => 'Chris'} }
+  #
+  # +serialize+ takes a format (<tt>:xml</tt>, <tt>:yaml</tt>, or <tt>:json</tt> - see New Formats below)
+  # and a hash of options.
+  # The only option currently recognized is <tt>:attributes</tt>,
+  # which has the same semantics
+  # as the <tt>:attributes</tt> option for Builder#publish.
+  # +serialize+ returns a string containing the target
+  # serialized in the given format.
+  # For example:
+  #
+  #   c = CandyBag.new(:title => 'jellybag')
+  #   c.candies << Candy.new(:type => 'jellybean', :flavor => 'root beer')
+  #   c.candies << Candy.new(:type => 'jellybean', :flavor => 'pear')
+  #   c.candies << Candy.new(:type => 'licorice',  :flavor => 'anisey')
+  #   c.serialize :xml, :attributes => [:title, {:candies => [:type, :flavor]}]
+  #
+  # This would return a Ruby string containing
+  #
+  #   <?xml version="1.0" encoding="UTF-8"?>
+  #   <candy-bag>
+  #     <title>jellybag</title>
+  #     <candies>
+  #       <candy>
+  #         <type>jellybean</type>
+  #         <flavor>root beer</flavor>
+  #       </candy>
+  #       <candy>
+  #         <type>jellybean</type>
+  #         <flavor>pear</flavor>
+  #       </candy>
+  #       <candy>
+  #         <type>licorice</type>
+  #         <flavor>anisey</flavor>
+  #       </candy>
+  #     </candies>
+  #   </candy-bag>
+  # 
+  module Serialize
+
+    # Takes an attributes option in the form passed to Builder#publish
+    # and returns a hash (or nil, if attributes is nil)
+    # containing the same data,
+    # but in a more consistent format.
+    # All keys are converted to symbols,
+    # and all lists are converted to hashes.
+    # For example:
+    #
+    #   Resourceful::Serialize.normalize_attributes([:foo, :bar, {"baz" => ["boom"]}])
+    #     #=> {"baz"=>["boom"], :foo=>nil, :bar=>nil}
+    # 
+    def self.normalize_attributes(attributes) # :nodoc:
+      return nil if attributes.nil?
+      return {attributes.to_sym => nil} if String === attributes
+      return {attributes => nil} if !attributes.respond_to?(:inject)
+
+      attributes.inject({}) do |hash, attr|
+        if Array === attr
+          hash[attr[0]] = attr[1]
+          hash
+        else
+          hash.merge normalize_attributes(attr)
+        end
+      end
+    end
+
+    # This module contains the definitions of +serialize+ and +to_serializable+
+    # that are included in ActiveRecord::Base.
+    module Model
+      # :call-seq:
+      #   serialize format, options = {}, :attributes => [ ... ]
+      #
+      # See the module documentation for Serialize for details.
+      def serialize(format, options)
+        raise "Must specify :attributes option" unless options[:attributes]
+        hash = self.to_serializable(options[:attributes])
+        root = self.class.to_s.underscore
+        if format == :xml
+          hash.send("to_#{format}", :root => root)
+        else
+          {root => hash}.send("to_#{format}")
+        end
+      end
+
+      # See the module documentation for Serialize for details.
+      def to_serializable(attributes)
+        raise "Must specify attributes for #{self.inspect}.to_serializable" if attributes.nil?
+
+        Serialize.normalize_attributes(attributes).inject({}) do |hash, (key, value)|
+          hash[key.to_s] = attr_hash_value(self.send(key), value)
+          hash
+        end
+      end
+
+      private
+
+      # Given an attribute value
+      # and a normalized (see above) attribute hash,
+      # returns the serializable form of that attribute.
+      def attr_hash_value(attr, sub_attributes)
+        if attr.respond_to?(:to_serializable)
+          attr.to_serializable(sub_attributes)
+        else
+          attr
+        end
+      end
+    end
+
+    # This module contains the definitions of +serialize+ and +to_serializable+
+    # that are included in ActiveRecord::Base.
+    module Array
+      # :call-seq:
+      #   serialize format, options = {}, :attributes => [ ... ]
+      #
+      # See the module documentation for Serialize for details.      
+      def serialize(format, options)
+        raise "Not all elements respond to to_serializable" unless all? { |e| e.respond_to? :to_serializable }
+        raise "Must specify :attributes option" unless options[:attributes]
+
+        serialized = map { |e| e.to_serializable(options[:attributes]) }
+        root = first.class.to_s.pluralize.underscore
+
+        if format == :xml
+          serialized.send("to_#{format}", :root => root)
+        else
+          {root => serialized}.send("to_#{format}")
+        end
+      end
+
+      # See the module documentation for Serialize for details.
+      def to_serializable(attributes)
+        if first.respond_to?(:to_serializable)
+          attributes = Serialize.normalize_attributes(attributes)
+          map { |e| e.to_serializable(attributes) }
+        else
+          self
+        end
+      end
+    end
+  end
+end
+
+if defined? ActiveModel
+  class ActiveModel::Base; include Resourceful::Serialize::Model; end
+else
+  class ActiveRecord::Base; include Resourceful::Serialize::Model; end
+end
+class Array; include Resourceful::Serialize::Array; end

data/spec/accessors_spec.rb

@@ -0,0 +1,474 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Resourceful::Default::Accessors, "#current_objects" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @objects = stub_list 5, 'object'
+    @model = stub
+    @controller.stubs(:current_model).returns(@model)
+  end
+
+  it "should look up all objects in the current model" do
+    @model.expects(:find).with(:all).returns(@objects)
+    @controller.current_objects.should == @objects
+  end
+
+  it "should cache the result, so subsequent calls won't run multiple queries" do
+    @model.expects(:find).once.returns(@objects)
+    @controller.current_objects
+    @controller.current_objects
+  end
+
+  it "shouldn't run a query if @current_objects is set" do
+    @controller.instance_variable_set('@current_objects', @objects)
+    @model.expects(:find).never
+    @controller.current_objects.should == @objects
+  end
+end
+
+describe Resourceful::Default::Accessors, "#load_objects" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @objects = stub_list 5, 'object'
+    @controller.stubs(:current_objects).returns(@objects)
+    @controller.stubs(:instance_variable_name).returns("posts")
+  end
+
+  it "should set the current instance variable to the object collection" do
+    @controller.load_objects
+    @controller.instance_variable_get('@posts').should == @objects
+  end
+end
+
+describe Resourceful::Default::Accessors, "#current_object on a plural controller" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.stubs(:plural?).returns(true)
+    @controller.stubs(:params).returns(:id => "12")
+
+    @object = stub
+    @model = stub
+    @controller.stubs(:current_model).returns(@model)
+  end
+
+  it "should look up the object specified by the :id parameter in the current model" do
+    @model.expects(:find).with('12').returns(@object)
+    @controller.current_object.should == @object
+  end
+
+  it "should cache the result, so subsequent calls won't run multiple queries" do
+    @model.expects(:find).once.returns(@object)
+    @controller.current_object
+    @controller.current_object
+  end
+
+  it "shouldn't run a query if @current_object is set" do
+    @controller.instance_variable_set('@current_object', @object)
+    @model.expects(:find).never
+    @controller.current_object.should == @object
+  end
+end
+
+describe Resourceful::Default::Accessors, "#current_object on a singular controller" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.stubs(:plural?).returns(false)
+    @controller.stubs(:controller_name).returns("posts")
+
+    @parent = stub('parent')
+    @controller.stubs(:parent_object).returns(@parent)
+    @controller.stubs(:parent?).returns(true)
+
+    @object = stub
+  end
+
+  it "should return the instance object from parent object" do
+    @parent.expects(:post).returns(@object)
+    @controller.current_object.should == @object
+  end
+end
+
+describe Resourceful::Default::Accessors, "#load_object" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @object = stub
+    @controller.stubs(:current_object).returns(@object)
+    @controller.stubs(:instance_variable_name).returns("posts")
+  end
+
+  it "should set the current singular instance variable to the current object" do
+    @controller.load_object
+    @controller.instance_variable_get('@post').should == @object
+  end
+end
+
+describe Resourceful::Default::Accessors, "#build_object with a #build-able model" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @params = {:name => "Bob", :password => "hideously insecure"}
+    @controller.stubs(:object_parameters).returns(@params)
+
+    @object = stub
+    @model = stub
+    @controller.stubs(:current_model).returns(@model)
+
+    @model.stubs(:build).returns(@object)
+  end
+
+  it "should return a new object built with current_model from the object parameters" do
+    @model.expects(:build).with(@params).returns(@object)
+    @controller.build_object.should == @object
+  end
+
+  it "should make current_object return the newly built object" do
+    @controller.build_object
+    @controller.current_object.should == @object
+  end
+end
+
+describe Resourceful::Default::Accessors, "#build_object with a non-#build-able model" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @params = {:name => "Bob", :password => "hideously insecure"}
+    @controller.stubs(:object_parameters).returns(@params)
+
+    @controller.stubs(:singular?).returns(false)
+    @controller.stubs(:parent?).returns(false)
+
+    @object = stub
+    @model = stub
+    @controller.stubs(:current_model).returns(@model)
+
+    @model.stubs(:new).returns(@object)
+  end
+
+  it "should return a new instance of the current_model built with the object parameters" do
+    @model.expects(:new).with(@params).returns(@object)
+    @controller.build_object.should == @object
+  end
+end
+
+describe Resourceful::Default::Accessors, "#current_model_name" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.stubs(:controller_name).returns("funky_posts")
+  end
+
+  it "should return the controller's name, singularized and camel-cased" do
+    @controller.current_model_name.should == "FunkyPost"
+  end
+end
+
+describe Resourceful::Default::Accessors, "#namespaces" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @kontroller.stubs(:name).returns("FunkyStuff::Admin::Posts")
+  end
+
+  it "should return an array of underscored symbols representing the namespaces of the controller class" do
+    @controller.namespaces.should == [:funky_stuff, :admin]
+  end
+
+  it "should cache the result, so subsequent calls won't run multiple computations" do
+    @kontroller.expects(:name).once.returns("Posts")
+    @controller.namespaces
+    @controller.namespaces
+  end
+end
+
+describe Resourceful::Default::Accessors, "#instance_variable_name" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.stubs(:controller_name).returns("posts")
+  end
+  
+  it "should return controller_name" do
+    @controller.instance_variable_name == "posts"
+  end
+end
+
+describe Resourceful::Default::Accessors, "#current_model for a singular controller" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    stub_const :Post
+    @controller.stubs(:singular?).returns(true)
+    @controller.stubs(:current_model_name).returns("Post")
+
+    @parent = stub('parent')
+    @controller.stubs(:parent_object).returns(@parent)
+    @controller.stubs(:parent?).returns(true)
+  end
+  
+  it "should return the constant named by current_model_name" do
+    @controller.current_model.should == Post
+  end
+end
+
+describe Resourceful::Default::Accessors, "#current_model for a plural controller with no parent" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    stub_const :Post
+    @controller.stubs(:singular?).returns(false)
+    @controller.stubs(:current_model_name).returns("Post")
+    @controller.stubs(:parent?).returns(false)
+  end
+  
+  it "should return the constant named by current_model_name" do
+    @controller.current_model.should == Post
+  end
+end
+
+describe Resourceful::Default::Accessors, "#object_parameters" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @params = {"crazy_user" => {:name => "Hampton", :location => "Canada"}}
+    @controller.stubs(:params).returns(@params)
+    @controller.stubs(:current_model_name).returns("CrazyUser")
+  end
+
+  it "should return the element of the params hash with the name of the model" do
+    @controller.object_parameters.should == @params["crazy_user"]
+  end
+end
+
+describe Resourceful::Default::Accessors, " with two parent classes set on the controller class and one parent parameter supplied" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @parents = %w{post comment}
+    @models = @parents.map(&:camelize).map(&method(:stub_const))
+    @kontroller.parents = @parents
+    @controller.stubs(:singular?).returns(false)
+    @controller.stubs(:instance_variable_name).returns('lines')
+
+    @params = HashWithIndifferentAccess.new :post_id => 12
+    @controller.stubs(:params).returns(@params)
+
+    @post = stub('Post')
+    Post.stubs(:find).returns(@post)
+
+    @model = stub
+  end
+
+  it "should return true for #parent?" do
+    @controller.parent?.should be_true
+  end
+
+  it "should return the string names of all the parents for #parent_names" do
+    @controller.parent_names.should == @parents
+  end
+
+  it "should return the string name of the current parent for #parent_name" do
+    @controller.parent_name.should == 'post'
+  end
+
+  it "should return the model class for #parent_model" do
+    @controller.parent_model.should == Post
+  end
+
+  it "should return the parent object for #parent_object" do
+    Post.expects(:find).with(12).returns(@post)
+    @controller.parent_object.should == @post
+  end
+
+  it "should cache the value of #parent_object so multiple calls won't cause multiple queries" do
+    Post.expects(:find).returns(@post).once
+    @controller.parent_object
+    @controller.parent_object
+  end
+
+  it "should bind the parent object its proper instance variable" do
+    @controller.load_parent_object
+    @controller.instance_variable_get('@post').should == @post
+  end
+
+  it "should return the parent-scoped model for #current_model" do
+    @post.stubs(:lines).returns(@model)
+    @controller.current_model.should == @model
+  end
+
+  it "should return true for #ensure_parent_exists" do
+    @controller.expects(:render).never
+    @controller.ensure_parent_exists.should be_true
+  end
+end
+
+describe Resourceful::Default::Accessors, " with two parent classes set on the controller class but no parent parameter supplied" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @parents = %w{post comment}
+    @models = @parents.map(&:camelize).map(&method(:stub_const))
+    @kontroller.parents = @parents
+    @controller.stubs(:params).returns({})
+    @controller.stubs(:controller_name).returns('line')
+    stub_const('Line')
+  end
+
+  it "should return false for #parent?" do
+    @controller.parent?.should be_false
+  end
+
+  it "should return nil for #parent_name" do
+    @controller.parent_name.should be_nil
+  end
+
+  it "should return the unscoped model for #current_model" do
+    @controller.current_model.should == Line
+  end
+
+  it "should return false and render a 422 error for #ensure_parent_exists" do
+    @controller.expects(:render).with(has_entry(:status, 422))
+    @controller.ensure_parent_exists.should be_false
+  end
+end
+
+describe Resourceful::Default::Accessors, " with no parents" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.stubs(:parents).returns([])
+    @controller.stubs(:current_model_name).returns('Line')
+    @controller.stubs(:params).returns({})
+    stub_const 'Line'
+  end
+
+  it "should return false for #parent?" do
+    @controller.parent?.should be_false
+  end
+
+  it "should return nil for #parent_name" do
+    @controller.parent_name.should be_nil
+  end
+
+  it "should return the unscoped model for #current_model" do
+    @controller.current_model.should == Line
+  end
+end
+
+describe Resourceful::Default::Accessors, " for a singular controller with a parent" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.stubs(:singular?).returns(true)
+    
+    @model = stub_model('Thing')    
+    @model.send(:attr_accessor, :person_id)
+    @controller.stubs(:current_model).returns(@model)
+
+    @person = stub_model('Person')
+    @person.stubs(:id).returns 42
+    @controller.stubs(:parent_object).returns(@person)
+    @controller.stubs(:parent_name).returns('person')
+    @controller.stubs(:parent?).returns(true)
+
+    @controller.stubs(:object_parameters).returns :thinginess => 12, :bacon => true
+  end
+
+  it "should set assign the parent's id to a newly built object" do
+    thing = @controller.build_object
+    thing.thinginess.should == 12
+    thing.person_id.should == @person.id
+  end
+end
+
+describe Resourceful::Default::Accessors, "#save_succeeded!" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.save_succeeded!
+  end
+
+  it "should make #save_succeeded? return true" do
+    @controller.save_succeeded?.should be_true
+  end
+end
+
+describe Resourceful::Default::Accessors, "#save_failed!" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.save_failed!
+  end
+
+  it "should make #save_succeeded? return false" do
+    @controller.save_succeeded?.should be_false
+  end
+end
+
+describe Resourceful::Default::Accessors, " for a plural action" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.stubs(:params).returns :action => "index"
+  end
+
+  it "should know it's a plural action" do
+    @controller.should be_a_plural_action
+  end
+
+  it "should know it's not a singular action" do
+    @controller.should_not be_a_singular_action
+  end
+end
+
+describe Resourceful::Default::Accessors, " for a singular action" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.stubs(:params).returns :action => "show"
+  end
+
+  it "should know it's not a plural action" do
+    @controller.should_not be_a_plural_action
+  end
+
+  it "should know it's a singular action" do
+    @controller.should be_a_singular_action
+  end
+end
+
+describe Resourceful::Default::Accessors, " for a singular controller" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.stubs(:instance_variable_name).returns "post"
+  end
+
+  it "should know it's not plural" do
+    @controller.should_not be_plural
+  end
+
+  it "should know it's singular" do
+    @controller.should be_singular
+  end
+end
+
+describe Resourceful::Default::Accessors, " for a plural controller" do
+  include ControllerMocks
+  before :each do
+    mock_controller Resourceful::Default::Accessors
+    @controller.stubs(:instance_variable_name).returns "posts"
+  end
+
+  it "should know it's plural" do
+    @controller.should be_plural
+  end
+
+  it "should know it's not singular" do
+    @controller.should_not be_singular
+  end
+end