coast 0.9.0 → 0.9.1

data/lib/coast.rb

@@ -80,23 +80,19 @@ module Coast
   # -----------------------------------------------------------------------------------------------
   # begin restful actions
 
-
   # begin UI actions
   def new
     invoke_callback(:before_new)
     @resourceful_item ||= resourceful_model.new
     send(self.class.authorize_method, :new, @resourceful_item, request)
     init_instance_variables
-
     invoke_callback(:respond_to_new)
     unless performed?
       respond_to do |format|
         format.html { render :new }
-        format.xml { render :xml => { :message => "Format not supported! Use the html format." } }
-        format.json { render :json => { :message => "Format not supported! Use the html format." } }
+        format_json_and_xml(format, :message => "Format not supported! Use the html format.")
       end
     end
-
     invoke_callback(:after_new)
   end
 
@@ -106,36 +102,29 @@ module Coast
     send(self.class.authorize_method, :edit, @resourceful_item, request)
     init_instance_variables
     invoke_callback(:respond_to_edit)
-
     unless performed?
       respond_to do |format|
         format.html { render :edit }
-        format.xml { render :xml => { :message => "Format not supported! Use the html format." } }
-        format.json { render :json => { :message => "Format not supported! Use the html format." } }
+        format_json_and_xml(format, :message => "Format not supported! Use the html format.")
       end
     end
-
     invoke_callback(:after_edit)
   end
   # end UI actions
 
-
   # begin READ actions
   def index
     invoke_callback(:before_index)
     @resourceful_list ||= resourceful_model.all
     send(self.class.authorize_method, :index, @resourceful_list, request)
     init_instance_variables
-
     invoke_callback(:respond_to_index)
     unless performed?
       respond_to do |format|
         format.html { render :index }
-        format.xml { render :xml => @resourceful_list }
-        format.json { render :json => @resourceful_list }
+        format_json_and_xml(format, @resourceful_list)
       end
     end
-
     invoke_callback(:after_index)
   end
 
@@ -144,21 +133,17 @@ module Coast
     @resourceful_item ||= resourceful_model.find(params[:id])
     send(self.class.authorize_method, :show, @resourceful_item, request)
     init_instance_variables
-
     invoke_callback(:respond_to_show)
     unless performed?
       respond_to do |format|
         format.html { render :show }
-        format.xml { render :xml => @resourceful_item }
-        format.json { render :json => @resourceful_item }
+        format_json_and_xml(format, @resourceful_item)
       end
     end
-
     invoke_callback(:after_show)
   end
   # end READ actions
 
-
   # begin MUTATING actions
   def create
     invoke_callback(:before_create)
@@ -166,23 +151,19 @@ module Coast
     send(self.class.authorize_method, :create, @resourceful_item, request)
     init_instance_variables
     success = @skip_db_create || @resourceful_item.save
-
     invoke_callback(:respond_to_create)
     unless performed?
       respond_to do |format|
         if success
           flash[:notice] = "#{resourceful_model.name} was successfully created."
           format.html { redirect_to(@resourceful_item) }
-          format.xml { render :xml => @resourceful_item, :status => :created, :location => @resourceful_item }
-          format.json { render :json => @resourceful_item, :status => :created, :location => @resourceful_item }
+          format_json_and_xml(format, @resourceful_item, :status => :created, :location => @resourceful_item)
         else
           format.html { render :action => "new" }
-          format.xml { render :xml => @resourceful_item.errors, :status => :unprocessable_entity }
-          format.json { render :json => @resourceful_item.errors, :status => :unprocessable_entity }
+          format_json_and_xml(format, @resourceful_item.errors, :status => :unprocessable_entity)
         end
       end
     end
-
     invoke_callback(:after_create)
   end
 
@@ -192,23 +173,19 @@ module Coast
     send(self.class.authorize_method, :update, @resourceful_item, request)
     init_instance_variables
     success = @skip_db_update || @resourceful_item.update_attributes(params[resourceful_model.name.underscore])
-
     invoke_callback(:respond_to_update)
     unless performed?
       respond_to do |format|
         if success
           flash[:notice] = "#{resourceful_model.name} was successfully updated."
           format.html { redirect_to(@resourceful_item) }
-          format.xml { render :xml => @resourceful_item }
-          format.json { render :json => @resourceful_item }
+          format_json_and_xml(format, @resourceful_item)
         else
           format.html { render :action => "edit" }
-          format.xml { render :xml => @resourceful_item.errors, :status => :unprocessable_entity }
-          format.json { render :json => @resourceful_item.errors, :status => :unprocessable_entity }
+          format_json_and_xml(format, @resourceful_item.errors, :status => :unprocessable_entity)
         end
       end
     end
-
     invoke_callback(:after_update)
   end
 
@@ -218,17 +195,14 @@ module Coast
     send(self.class.authorize_method, :destroy, @resourceful_item, request)
     init_instance_variables
     @resourceful_item.destroy unless @skip_db_destroy
-
     invoke_callback(:respond_to_destroy)
     unless performed?
       flash[:notice] = "#{resourceful_model.name} was successfully destroyed" if @resourceful_item.destroyed?
       respond_to do |format|
         format.html { redirect_to root_url }
-        format.xml { render :xml => @resourceful_item }
-        format.json { render :json => @resourceful_item }
+        format_json_and_xml(format, @resourceful_item)
       end
     end
-
     invoke_callback(:after_destroy)
   end
   # end MUTATING actions
@@ -250,7 +224,6 @@ module Coast
   def item_instance_var_name
     return @item_instance_var_name if @item_instance_var_name
     name = resourceful_model.name.underscore.gsub("/", "_")
-    puts name
     @item_instance_var_name ||= "@#{name}"
   end
 
@@ -264,4 +237,9 @@ module Coast
     send(name) if respond_to?(name)
   end
 
+  def format_json_and_xml(format, data, options={})
+    format.xml { render({:xml => data}.merge(options)) }
+    format.json { render({:json => data}.merge(options)) }
+  end
+
 end

data/spec/coast_spec.rb

@@ -0,0 +1,245 @@
+require "rubygems"
+
+# fix MiniTest issue with 1.9
+unless defined? Gem::Deprecate
+  module Gem
+    Deprecate = Module.new do
+      include Deprecate
+    end
+  end
+end
+
+require "bundler/setup"
+require "minitest/autorun"
+require "active_support/all"
+require "turn"
+require "pry"
+
+dirname = File.dirname(__FILE__)
+require File.join(dirname, "mock")
+Dir.glob(File.join(dirname, "..", "lib", "*.rb")) { |f| require f }
+MODEL_PATH = File.join(dirname, "testable_model.rb")
+CONTROLLER_PATH = File.join(dirname, "testable_controller.rb")
+load MODEL_PATH
+load CONTROLLER_PATH
+
+
+
+
+describe Coast do
+  RESTFUL_METHODS = %w(index show new edit create update destroy)
+  ITEM_METHODS    = %w(show new edit create update destroy)
+  UI_METHODS      = %w(new edit)
+  READ_METHODS    = %w(index show)
+  MUTATE_METHODS  = %w(create update destroy)
+
+  # Resets the mock class defs.
+  def reset
+    Coast.send(:remove_const, :TestableController)
+    Coast.send(:remove_const, :TestableModel)
+    load MODEL_PATH
+    load CONTROLLER_PATH
+    Coast::TestableController.set_resourceful_model Coast::TestableModel
+  end
+
+  # class method tests ============================================================================
+
+  describe :set_authorize_method do
+    it "sets the method used to perform authorization checks" do
+      reset
+      Coast::TestableController.set_authorize_method :authorize!
+      assert Coast::TestableController.authorize_method == :authorize!
+    end
+  end
+
+  describe :authorize_method= do
+    it "sets the method used to perform authorization checks" do
+      reset
+      Coast::TestableController.authorize_method = :authorize!
+      assert Coast::TestableController.authorize_method == :authorize!
+    end
+  end
+
+  describe :set_resourceful_model do
+    it "sets the model that the controller manages" do
+      reset
+      model = Object.new
+      Coast::TestableController.set_resourceful_model model
+      assert Coast::TestableController.resourceful_model == model
+    end
+  end
+
+  describe :resourceful_model= do
+    it "sets the model that the controller manages" do
+      reset
+      model = Object.new
+      Coast::TestableController.resourceful_model = model
+      assert Coast::TestableController.resourceful_model == model
+    end
+  end
+
+  def verify_callback_setter(event, action)
+    reset
+    Coast::TestableController.send(event, action, &(lambda {}))
+    assert Coast::TestableController.new.respond_to?("#{event}_#{action}")
+  end
+
+  describe :before do
+    it "stores a before callback for all RESTful actions" do
+      RESTFUL_METHODS.each { |m| verify_callback_setter :before, m }
+    end
+  end
+
+  describe :respond_to do
+    it "stores a respond_to callback for all RESTful actions" do
+      RESTFUL_METHODS.each { |m| verify_callback_setter :respond_to, m }
+    end
+  end
+
+  describe :after do
+    it "stores an after callback for all RESTful actions" do
+      RESTFUL_METHODS.each { |m| verify_callback_setter :after, m }
+    end
+  end
+
+
+
+
+
+
+
+
+
+
+
+  # instance method tests =========================================================================
+
+
+  it "supports all RESTful methods" do
+    reset
+    controller = Coast::TestableController.new
+    RESTFUL_METHODS.each { |m| controller.must_respond_to m }
+  end
+
+  # %w(index show new).each do |method|
+  RESTFUL_METHODS.each do |method|
+    describe "##{method}" do
+      before do
+        reset
+      end
+
+      it "responds and renders" do
+        controller = Coast::TestableController.new
+        controller.send(method)
+        assert controller.responded?, "Did not respond"
+        assert controller.rendered?, "Did not render"
+      end
+
+      it "renders for the formats html, xml, json" do
+        controller = Coast::TestableController.new
+        controller.send(method)
+        assert controller.html, "Did not respond to the html format"
+        assert controller.xml, "Did not respond to the xml format"
+        assert controller.json, "Did not respond to the json format"
+      end
+
+      it "invokes the callbacks before, respond_to, after" do
+        callbacks = []
+
+        Coast::TestableController.class_eval do
+          before(method) { callbacks << :before }
+          respond_to(method) { callbacks << :respond_to }
+          after(method) { callbacks << :after }
+        end
+
+        controller = Coast::TestableController.new
+        controller.send(method)
+        assert callbacks.include?(:before), "Did not invoke the before callback"
+        assert callbacks.include?(:respond_to), "Did not invoke the respond_to callback"
+        assert callbacks.include?(:after), "Did not invoke the after callback"
+      end
+
+      it "allows :respond_to callback to perform the render" do
+        Coast::TestableController.respond_to(method) { @performed = true }
+        controller = Coast::TestableController.new
+        controller.send(method)
+        assert controller.responded? == false, "Did not allow :respond_to callback to perform the render"
+      end
+
+      it "invokes the authorize_method when set" do
+        Coast::TestableController.authorize_method = :authorize!
+        controller = Coast::TestableController.new
+        controller.send(:index)
+        assert controller.authorize_invoked?, "Did not invoke the authorize_method"
+      end
+
+    end
+  end
+
+  ITEM_METHODS.each do |method|
+    describe "##{method}" do
+      before do
+        reset
+      end
+
+      it "allows :before callback to set the item" do
+        item = Object.new
+        Coast::TestableController.before(:index) { @resourceful_item = item }
+        controller = Coast::TestableController.new
+        controller.index
+        assert controller.instance_eval { @resourceful_item } == item, "Did not allow :before callback to set the resourceful_item"
+      end
+
+      it "sets a custom named instance variable for the item" do
+        item = Object.new
+        Coast::TestableController.before(:index) { @resourceful_item = item }
+        controller = Coast::TestableController.new
+        controller.index
+        variable = controller.instance_eval { instance_variable_get(item_instance_var_name) }
+        assert variable != nil, "Did not set a custom instance variable for the item"
+        assert variable == item, "Did not set a custom instance variable for the item to the correct value"
+      end
+
+    end
+  end
+
+  MUTATE_METHODS.each do |method|
+    describe "##{method}" do
+      before do
+        reset
+      end
+
+      it "redirects" do
+        controller = Coast::TestableController.new
+        controller.send(method)
+        assert controller.redirected?, "Did not redirect"
+      end
+    end
+  end
+
+
+  describe "#index" do
+    before do
+      reset
+    end
+
+    it "allows :before callback to set the list" do
+      list = [ Object.new ]
+      Coast::TestableController.before(:index) { @resourceful_list = list }
+      controller = Coast::TestableController.new
+      controller.index
+      assert controller.instance_eval { @resourceful_list } == list, "Did not allow :before callback to set the resourceful_list"
+    end
+
+    it "sets a custom named instance variable for the item" do
+      list = [ Object.new ]
+      Coast::TestableController.before(:index) { @resourceful_list = list }
+      controller = Coast::TestableController.new
+      controller.index
+      variable = controller.instance_eval { instance_variable_get(list_instance_var_name) }
+      assert variable != nil, "Did not set a custom instance variable for the item"
+      assert variable == list, "Did not set a custom instance variable for the item to the correct value"
+    end
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coast
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.1
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &2164573380 !ruby/object:Gem::Requirement
+  requirement: &2160361220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,14 +21,16 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2164573380
+  version_requirements: *2160361220
 description: Resourceful behavior for Rails controllers with a Sinatra like DSL.
-email: nate.hop@gmail.com
+email:
+- nate.hop@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/coast.rb
+- spec/coast_spec.rb
 homepage: https://github.com/hopsoft/coast
 licenses:
 - MIT
@@ -54,4 +56,5 @@ rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Coast
-test_files: []
+test_files:
+- spec/coast_spec.rb