carlosbrando-remarkable 0.0.99

data/lib/remarkable/controller/macros/route.rb

@@ -0,0 +1,91 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      # Macro that creates a routing test. It tries to use the given HTTP
+      # +method+ on the given +path+, and asserts that it routes to the
+      # given +options+.
+      #
+      # +to_param+ is called on the +options+ given.
+      #
+      # Examples:
+      #
+      #   it { should route(:get, "/posts", :controller => :posts, :action => :index) }
+      #   it { should route(:get, "/posts/new", :controller => :posts, :action => :new) }
+      #   it { should route(:post, "/posts", :controller => :posts, :action => :create) }
+      #   it { should route(:get, "/posts/1", :controller => :posts, :action => :show, :id => 1) }
+      #   it { should route(:edit, "/posts/1", :controller => :posts, :action => :show, :id => 1) }
+      #   it { should route(:put, "/posts/1", :controller => :posts, :action => :update, :id => 1) }
+      #   it { should route(:delete, "/posts/1", :controller => :posts, :action => :destroy, :id => 1) }
+      #   it do
+      #     should route :get, "/users/1/posts/1", :controller => :posts, :action => :show, :id => 1, :user_id => 1
+      #   end
+      #
+      def route(method, path, options)
+        simple_matcher "route #{method.to_s.upcase} #{path} to/from #{options.inspect}" do |controller|
+          unless options[:controller]
+            options[:controller] = controller.name.gsub(/Controller$/, '').tableize
+          end
+          options[:controller] = options[:controller].to_s
+          options[:action] = options[:action].to_s
+
+          populated_path = path.dup
+          options.each do |key, value|
+            options[key] = value.to_param if value.respond_to? :to_param
+            populated_path.gsub!(key.inspect, value.to_s)
+          end
+
+          route_for(options).should == populated_path && params_from(method.to_sym, populated_path).should == options
+        end
+      end
+    end
+
+    module Shoulda
+      # Macro that creates a routing test. It tries to use the given HTTP
+      # +method+ on the given +path+, and asserts that it routes to the
+      # given +options+.
+      #
+      # +to_param+ is called on the +options+ given.
+      #
+      # Examples:
+      #
+      #   should_route :get, "/posts", :controller => :posts, :action => :index
+      #   should_route :get, "/posts/new", :controller => :posts, :action => :new
+      #   should_route :post, "/posts", :controller => :posts, :action => :create
+      #   should_route :get, "/posts/1", :controller => :posts, :action => :show, :id => 1
+      #   should_route :edit, "/posts/1", :controller => :posts, :action => :show, :id => 1
+      #   should_route :put, "/posts/1", :controller => :posts, :action => :update, :id => 1
+      #   should_route :delete, "/posts/1", :controller => :posts, :action => :destroy, :id => 1
+      #   should_route :get, "/users/1/posts/1",
+      #     :controller => :posts, :action => :show, :id => 1, :user_id => 1
+      #
+      def should_route(method, path, options)
+        populated_path = path.dup
+
+        unless options[:controller]
+          it "should explicitly specify :controller" do
+            options[:controller].should_not be_nil
+          end
+          return
+        end
+
+        options[:controller] = options[:controller].to_s
+        options[:action] = options[:action].to_s
+
+        options.each do |key, value|
+          options[key] = value.to_param if value.respond_to? :to_param
+          populated_path.gsub!(key.inspect, value.to_s)
+        end
+
+        it "should map #{options.inspect} to #{path.inspect}" do
+          route_for(options).should == populated_path
+        end
+
+        it "should generate params #{options.inspect} from #{method.to_s.upcase} to #{path.inspect}" do
+          params_from(method.to_sym, populated_path).should == options
+        end
+      end
+    end
+    
+  end
+end

data/lib/remarkable/controller/macros/set_the_flash_to.rb

@@ -0,0 +1,58 @@
+module Remarkable
+  module Syntax
+
+    module RSpec
+      # Macro that creates a test asserting that the flash contains the given value.
+      # val can be a String, a Regex, or nil (indicating that the flash should not be set)
+      #
+      # Example:
+      #
+      #   should_set_the_flash_to "Thank you for placing this order."
+      #   should_set_the_flash_to /created/i
+      #   should_set_the_flash_to nil
+      # 
+      def set_the_flash_to(val = nil)
+        if val
+          simple_matcher "should have #{val.inspect} in the flash" do
+            assert_contains(flash.values, val)
+          end
+        else
+          simple_matcher "should not set the flash" do
+            assert_equal({}, flash)
+          end
+        end
+      end
+      alias_method :set_the_flash, :set_the_flash_to
+    end
+
+    module Shoulda
+      # Macro that creates a test asserting that the flash contains the given value.
+      # val can be a String, a Regex, or nil (indicating that the flash should not be set)
+      #
+      # Example:
+      #
+      #   should_set_the_flash_to "Thank you for placing this order."
+      #   should_set_the_flash_to /created/i
+      #   should_set_the_flash_to nil
+      # 
+      def should_set_the_flash_to(val)
+        if val
+          it "should have #{val.inspect} in the flash" do
+            assert_contains(flash.values, val)
+          end
+        else
+          it "should not set the flash" do
+            assert_equal({}, flash)
+          end
+        end
+      end
+
+      # Macro that creates a test asserting that the flash is empty.  Same as
+      # @should_set_the_flash_to nil@
+      def should_not_set_the_flash
+        should_set_the_flash_to nil
+      end
+    end
+
+  end
+end

data/lib/remarkable/example/example_methods.rb

@@ -0,0 +1,32 @@
+module Spec
+  module Example
+    module ExampleMethods
+      def should(matcher)
+        case matcher.class.name
+        when "Spec::Rails::Matchers::RenderTemplate", "Spec::Rails::Matchers::RedirectTo"
+          remarkable_response.should matcher
+        else
+          remarkable_subject.should matcher
+        end
+      end
+
+      def should_not(matcher)
+        case matcher.class.name
+        when "Spec::Rails::Matchers::RenderTemplate", "Spec::Rails::Matchers::RedirectTo"
+          remarkable_response.should_not matcher
+        else
+          remarkable_subject.should_not matcher
+        end
+      end
+
+      def remarkable_subject
+        @remarkable_subject = subject if self.respond_to?(:subject)
+        @remarkable_subject ||= self.class.described_type
+      end
+
+      def remarkable_response
+        @remarkable_response ||= self.response if self.respond_to?(:response)        
+      end
+    end
+  end
+end

data/lib/remarkable/private_helpers.rb

@@ -0,0 +1,123 @@
+module Remarkable # :nodoc:
+  module Private # :nodoc:
+    def fail(message)
+      @failure_message = message
+      raise Exception.new(message)
+    end
+
+    # Returns the values for the entries in the args hash who's keys are listed in the wanted array.
+    # Will raise if there are keys in the args hash that aren't listed.
+    def get_options!(args, *wanted)
+      ret  = []
+      opts = (args.last.is_a?(Hash) ? args.pop : {})
+      wanted.each {|w| ret << opts.delete(w)}
+      raise ArgumentError, "Unsupported options given: #{opts.keys.join(', ')}" unless opts.keys.empty?
+      return *ret
+    end
+
+    # Helper method that determines the default error message used by Active
+    # Record.  Works for both existing Rails 2.1 and Rails 2.2 with the newly
+    # introduced I18n module used for localization.
+    #
+    #   default_error_message(:blank)
+    #   default_error_message(:too_short, :count => 5)
+    #   default_error_message(:too_long, :count => 60)
+    def default_error_message(key, values = {})
+      if Object.const_defined?(:I18n) # Rails >= 2.2
+        I18n.translate("activerecord.errors.messages.#{key}", values)
+      else # Rails <= 2.1.x
+        ::ActiveRecord::Errors.default_error_messages[key] % values[:count]
+      end
+    end
+
+    # Asserts that an Active Record model validates with the passed
+    # <tt>value</tt> by making sure the <tt>error_message_to_avoid</tt> is not
+    # contained within the list of errors for that attribute.
+    #
+    #   assert_good_value(User.new, :email, "user@example.com")
+    #   assert_good_value(User.new, :ssn, "123456789", /length/)
+    #
+    # If a class is passed as the first argument, a new object will be
+    # instantiated before the assertion.  If an instance variable exists with
+    # the same name as the class (underscored), that object will be used
+    # instead.
+    #
+    #   assert_good_value(User, :email, "user@example.com")
+    #
+    #   @product = Product.new(:tangible => false)
+    #   assert_good_value(Product, :price, "0")
+    def assert_good_value(object_or_klass, attribute, value, error_message_to_avoid = //)
+      object = get_instance_of(object_or_klass)
+      object.send("#{attribute}=", value)
+      return true if object.valid?
+      assert_does_not_contain(object.errors.on(attribute), error_message_to_avoid)
+    end
+
+    # Asserts that an Active Record model invalidates the passed
+    # <tt>value</tt> by making sure the <tt>error_message_to_expect</tt> is
+    # contained within the list of errors for that attribute.
+    #
+    #   assert_bad_value(User.new, :email, "invalid")
+    #   assert_bad_value(User.new, :ssn, "123", /length/)
+    #
+    # If a class is passed as the first argument, a new object will be
+    # instantiated before the assertion.  If an instance variable exists with
+    # the same name as the class (underscored), that object will be used
+    # instead.
+    #
+    #   assert_bad_value(User, :email, "invalid")
+    #
+    #   @product = Product.new(:tangible => true)
+    #   assert_bad_value(Product, :price, "0")
+    def assert_bad_value(object_or_klass, attribute, value,
+      error_message_to_expect = self.class.default_error_message(:invalid))
+      object = get_instance_of(object_or_klass)
+      object.send("#{attribute}=", value)
+
+      return false if object.valid?
+      return false unless object.errors.on(attribute)
+      assert_contains(object.errors.on(attribute), error_message_to_expect)
+    end
+
+    # Asserts that the given collection contains item x.  If x is a regular expression, ensure that
+    # at least one element from the collection matches x.  +extra_msg+ is appended to the error message if the assertion fails.
+    #
+    #   assert_contains(['a', '1'], /\d/) => passes
+    #   assert_contains(['a', '1'], 'a') => passes
+    #   assert_contains(['a', '1'], /not there/) => fails
+    def assert_contains(collection, x)
+      collection = [collection] unless collection.is_a?(Array)
+      case x
+      when Regexp
+        return false unless collection.detect { |e| e =~ x }
+      else
+        return false unless collection.include?(x)
+      end
+      true
+    end
+
+    # Asserts that the given collection does not contain item x.  If x is a regular expression, ensure that
+    # none of the elements from the collection match x.
+    def assert_does_not_contain(collection, x)
+      collection = [collection] unless collection.is_a?(Array)
+      case x
+      when Regexp
+        return false if collection.detect { |e| e =~ x }
+      else
+        return false if collection.include?(x)
+      end
+      true
+    end
+
+    private
+
+    def get_instance_of(object_or_klass)
+      if object_or_klass.is_a?(Class)
+        klass = object_or_klass
+        instance_variable_get("@#{klass.to_s.underscore}") || klass.new
+      else
+        object_or_klass
+      end
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require "remarkable.rb"

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/remarkable.rb'}"
+puts "Loading remarkable gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/spec/controllers/posts_controller_spec.rb

@@ -0,0 +1,166 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe PostsController do
+  fixtures :all
+
+  # autodetects the :controller
+  should_route :get,    '/posts',             :controller => :posts, :action => :index
+  # explicitly specify :controller
+  should_route :post,   '/posts',             :controller => :posts, :action => :create
+  # non-string parameter
+  should_route :get,    '/posts/1',           :controller => :posts, :action => :show,    :id => 1
+  # string-parameter
+  should_route :put,    '/posts/1',           :controller => :posts, :action => :update,  :id => "1"
+  should_route :delete, '/posts/1',           :controller => :posts, :action => :destroy, :id => 1
+  should_route :get,    '/posts/new',         :controller => :posts, :action => :new
+
+  # Test the nested routes
+  should_route :get,    '/users/5/posts',     :controller => :posts, :action => :index,   :user_id => 5
+  should_route :post,   '/users/5/posts',     :controller => :posts, :action => :create,  :user_id => 5
+  should_route :get,    '/users/5/posts/1',   :controller => :posts, :action => :show,    :id => 1, :user_id => 5
+  should_route :delete, '/users/5/posts/1',   :controller => :posts, :action => :destroy, :id => 1, :user_id => 5
+  should_route :get,    '/users/5/posts/new', :controller => :posts, :action => :new,     :user_id => 5
+  should_route :put,    '/users/5/posts/1',   :controller => :posts, :action => :update,  :id => 1, :user_id => 5
+
+  describe "Logged in" do
+    before do
+      request.session[:logged_in] = true
+    end
+
+    describe "viewing posts for a user" do
+      before do
+        get :index, :user_id => users(:first)
+      end
+      should_respond_with 200
+      should_assign_to :user, :class => User, :equals => 'users(:first)'
+      it { lambda { should_assign_to(:user, :class => Post) }.should raise_error }
+      it { lambda { should_assign_to :user, :equals => 'posts(:first)' }.should raise_error }
+      should_assign_to :posts
+      should_not_assign_to :foo, :bar
+    end
+
+    describe "on POST to :create" do
+      before do
+        post :create, :post => { :title => "Title", :body => "Body" }, :user_id => users(:first)
+        @post = Post.last
+      end
+      should_respond_with :redirect
+      should_redirect_to "user_post_url(@post.user, @post)"
+      should_set_the_flash_to /created/i
+    end
+
+    describe "viewing posts for a user with rss format" do
+      before do
+        get :index, :user_id => users(:first), :format => 'rss'
+        @user = users(:first)
+      end
+      should_respond_with :success
+      should_respond_with_content_type 'application/rss+xml'
+      should_respond_with_content_type :rss
+      should_respond_with_content_type /rss/
+      should_return_from_session :special, "'$2 off your next purchase'"
+      should_return_from_session :special_user_id, '@user.id'
+      should_assign_to :user, :posts
+      should_not_assign_to :foo, :bar
+    end
+
+    describe "viewing a post on GET to #show" do
+      before { get :show, :user_id => users(:first), :id => posts(:first) }
+      should_render_with_layout 'wide'
+      should_render_with_layout :wide
+      should_render_template :show
+    end
+
+    describe "on GET to #new" do
+      before { get :new, :user_id => users(:first) }
+      should_render_without_layout
+      should_not_set_the_flash
+    end
+  end
+
+end
+
+describe PostsController do
+  fixtures :all
+
+  # autodetects the :controller
+  it { should route(:get,    '/posts',     :action => :index) }
+  # explicitly specify :controller
+  it { should route(:post,   '/posts',     :controller => :posts, :action => :create) }
+  # # non-string parameter
+  it { should route(:get,    '/posts/1',   :action => :show, :id => 1) }
+  # # string-parameter
+  it { should route(:put,    '/posts/1',   :action => :update, :id => "1") }
+  it { should route(:delete, '/posts/1',   :action => :destroy, :id => 1) }
+  it { should route(:get,    '/posts/new', :action => :new) }
+
+  # # Test the nested routes
+  it { should route(:get,    '/users/5/posts',     :action => :index, :user_id => 5) }
+  it { should route(:post,   '/users/5/posts',     :action => :create, :user_id => 5) }
+  it { should route(:get,    '/users/5/posts/1',   :action => :show, :id => 1, :user_id => 5) }
+  it { should route(:delete, '/users/5/posts/1',   :action => :destroy, :id => 1, :user_id => 5) }
+  it { should route(:get,    '/users/5/posts/new', :action => :new, :user_id => 5) }
+  it { should route(:put,    '/users/5/posts/1',   :action => :update, :id => 1, :user_id => 5) }
+
+  describe "Logged in" do
+    before do
+      request.session[:logged_in] = true
+    end
+
+    describe "viewing posts for a user" do
+      before do
+        get :index, :user_id => users(:first)
+      end
+      it { should respond_with(200) }
+      it { should assign_to(:user, :class => User, :equals => 'users(:first)') }
+      it { should_not assign_to(:user, :class => Post) }
+      it { should_not assign_to(:user, :equals => 'posts(:first)') }
+      it { should assign_to(:posts) }
+      it { should_not assign_to(:foo, :bar) }
+    end
+    
+    describe "on POST to :create" do
+      before(:each) do
+        post :create, :post => { :title => "Title", :body => "Body" }, :user_id => users(:first)
+        @post = Post.last
+      end
+      it { should respond_with(:redirect) }
+      it { should_not respond_with(:success) }
+      it { should redirect_to(user_post_url(@post.user, @post)) }
+      it { should set_the_flash_to(/created/i) }
+      it { should_not set_the_flash_to(/foo/i) }
+    end
+
+    describe "viewing posts for a user with rss format" do
+      before do
+        get :index, :user_id => users(:first), :format => 'rss'
+        @user = users(:first)
+      end
+      it { should respond_with(:success) }
+      it { should respond_with_content_type('application/rss+xml') }
+      it { should respond_with_content_type(:rss) }
+      it { should respond_with_content_type(/rss/) }
+      it { should return_from_session(:special, "'$2 off your next purchase'") }
+      it { should return_from_session(:special_user_id, '@user.id') }
+      it { should_not return_from_session(:monkey, "'fat'") }
+      it { should assign_to(:user, :posts) }
+      it { should_not assign_to(:foo, :bar) }
+    end
+
+    describe "viewing a post on GET to #show" do
+      before { get :show, :user_id => users(:first), :id => posts(:first) }
+      it { should render_with_layout('wide') }
+      it { should render_with_layout(:wide) }
+      it { should_not respond_with_content_type(:rss) }
+      it { should render_template(:show) }
+      it { should_not render_template(:new) }
+    end
+
+    describe "on GET to #new" do
+      before { get :new, :user_id => users(:first) }
+      it { should render_without_layout }
+      it { should_not set_the_flash }
+    end
+  end
+
+end