spicycode-micronaut-rails 0.0.6.1

data/LICENSE

@@ -0,0 +1,45 @@
+Copyright (c) 2008 Chad Humphries
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+The matchers and expectations are licensed:
+(The MIT License)
+
+Copyright (c) 2005-2008 The RSpec Development Team
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,17 @@
+= Micronaut Rails
+
+* http://github.com/spicycode/micronaut-rails
+
+== DESCRIPTION:
+
+Micronaut Rails is a set of extension to deal with rails mode testing. For the moment think of it is a prototype of
+RSpec lite.  Definitely pre alpha at the moment.
+
+== REQUIREMENTS:
+
++ Ruby 1.8
++ Micronaut (via spicycode-micronaut on GitHub) -- see Micronaut::Rails::Version::MICRONAUT_REQUIRED_VERSION for the required version of Micronaut for this version of micronaut-rails
+
+== CREDITS:
+
+* RSpec for the great ideas and matchers

data/RSPEC-LICENSE

@@ -0,0 +1,23 @@
+(The MIT License)
+ 
+Copyright (c) 2005-2008 The RSpec Development Team
+ 
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+ 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ 

data/Rakefile

@@ -0,0 +1,92 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require './lib/micronaut/rails/version'
+
+GEM = "micronaut-rails"
+GEM_VERSION = Micronaut::Rails::Version::STRING
+AUTHOR = "Chad Humphries"
+EMAIL = "chad@spicycode.com"
+HOMEPAGE = "http://spicycode.com"
+SUMMARY = "An excellent replacement for the wheel..."
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE", "RSPEC-LICENSE"]
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.bindir = 'bin'
+  s.require_path = 'lib'
+  s.autorequire = GEM
+  s.add_dependency "actionpack", '>= 2.2.2'
+  s.add_dependency "spicycode-micronaut", Micronaut::Rails::Version::MICRONAUT_REQUIRED_VERSION
+  s.files = %w(LICENSE README RSPEC-LICENSE Rakefile) + Dir.glob("{lib,examples}/**/*")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
+end
+
+desc "create a gemspec file"
+task :make_gemspec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+desc 'Run all examples'
+task :examples do
+  examples = Dir["examples/**/*_example.rb"].map { |g| Dir.glob(g) }.flatten
+  ruby examples.join(" ")
+end
+
+namespace :examples do
+  
+  desc "List files that don't have examples"
+  task :untested do
+    code = Dir["lib/**/*.rb"].map { |g| Dir.glob(g) }.flatten
+    examples = Dir["examples/**/*_example.rb"].map { |g| Dir.glob(g) }.flatten
+    examples.map! { |f| f =~ /examples\/(.*)_example/; "#{$1}.rb" }
+    missing_examples = (code - examples)
+    puts
+    puts "The following files seem to be missing their examples:"
+    missing_examples.each do |missing|
+      puts "  #{missing}"
+    end
+  end
+
+  desc "Run all examples using rcov"
+  task :coverage do
+    examples = Dir["examples/**/*_example.rb"].map { |g| Dir.glob(g) }.flatten
+    result = system "rcov --exclude \"examples/*,gems/*,db/*,/Library/Ruby/*,config/*\" --text-summary  --sort coverage --no-validator-links #{examples.join(' ')}"
+    fail_build unless result
+  end
+
+  def fail_build
+    puts
+    puts "-" * 79
+    puts "Build Failed"
+    puts "-" * 79
+    abort
+  end
+
+  desc "Delete coverage artifacts" 
+  task :clean_coverage do
+    rm_rf Dir["coverage/**/*"]
+  end
+
+end
+
+task :default => 'examples:coverage'
+task :clobber_package => 'examples:clean_coverage'

data/examples/example_helper.rb

@@ -0,0 +1,44 @@
+lib_path = File.expand_path(File.dirname(__FILE__) + "/../lib")
+$LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
+
+require 'micronaut/rails/version'
+gem "spicycode-micronaut", Micronaut::Rails::Version::MICRONAUT_REQUIRED_VERSION
+require 'micronaut'
+require 'micronaut-rails'
+require 'rubygems'
+gem :mocha
+
+module Micronaut  
+  module Matchers
+    def fail
+      raise_error(::Micronaut::Expectations::ExpectationNotMetError)
+    end
+
+    def fail_with(message)
+      raise_error(::Micronaut::Expectations::ExpectationNotMetError, message)
+    end
+  end
+end
+
+def remove_last_describe_from_world
+  Micronaut.world.behaviours.pop
+end
+
+class DummyFormatter <  Micronaut::Formatters::BaseTextFormatter; end
+
+def dummy_reporter
+  DummyFormatter.new({}, StringIO.new)
+end
+
+def use_color?
+  !ENV.has_key?('TM_MODE')
+end
+
+Micronaut.configure do |config|
+  config.mock_with :mocha
+  config.color_enabled = use_color?
+  config.formatter = :documentation
+  config.profile_examples = false
+  config.filter_run :focused => true
+  config.autorun!
+end

data/examples/lib/micronaut-rails_example.rb

@@ -0,0 +1,6 @@
+require File.expand_path(File.dirname(__FILE__) + "/../example_helper")
+
+describe Micronaut::Rails do
+
+  
+end

data/examples/lib/micronaut/rails/configuration_example.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + "/../../../example_helper")
+
+describe Micronaut::Rails::Configuration do
+
+  example "loading micronaut rails include it in the micronaut configuration class" do
+    Micronaut::Configuration.included_modules.should include(Micronaut::Rails::Configuration)
+  end
+  
+  it "should add a #rails method" do
+    Micronaut.configuration.should respond_to(:rails)
+  end
+  
+  it "should add an #enable_active_record_transactional_support method" do
+    Micronaut.configuration.should respond_to(:enable_active_record_transactional_support)
+  end
+
+end

data/lib/autotest/discover.rb

@@ -0,0 +1,3 @@
+Autotest.add_discovery do
+  "micronaut_rails" if File.directory?('examples')
+end

data/lib/autotest/micronaut-rails.rb

@@ -0,0 +1,48 @@
+require 'autotest'
+
+Autotest.add_hook :initialize do |at|
+  at.clear_mappings
+  # watch out: Ruby bug (1.8.6):
+  # %r(/) != /\//
+  at.add_mapping(%r%^examples/.*_example.rb$%) { |filename, _| 
+    filename 
+  }
+  at.add_mapping(%r%^lib/(.*)\.rb$%) { |filename, m| 
+    ["examples/lib/#{m[1]}_example.rb"]
+  }
+  at.add_mapping(%r%^examples/(example_helper|shared/.*)\.rb$%) { 
+    at.files_matching %r%^examples/.*_example\.rb$%
+  }
+end
+
+class MicronautCommandError < StandardError; end
+
+class Autotest::Micronaut < Autotest
+
+  def initialize
+    super
+    self.failed_results_re = /^\d+\)\n(?:\e\[\d*m)?(?:.*?Error in )?'([^\n]*)'(?: FAILED)?(?:\e\[\d*m)?\n(.*?)\n\n/m
+    self.completed_re = /\n(?:\e\[\d*m)?\d* examples?/m
+  end
+  
+  def consolidate_failures(failed)
+    filters = new_hash_of_arrays
+    failed.each do |spec, trace|
+      if trace =~ /\n(\.\/)?(.*example\.rb):[\d]+:\Z?/
+        filters[$2] << spec
+      end
+    end
+    return filters
+  end
+
+  def make_test_cmd(files_to_test)
+    return '' if files_to_test.empty?
+    
+    examples = files_to_test.keys.flatten
+    
+    examples.map! {|f| %Q(require "#{f}")}
+
+    return "#{ruby} -e '#{examples.join("; ")}'"
+  end
+  
+end

data/lib/autotest/micronaut_rails.rb

@@ -0,0 +1,48 @@
+require 'autotest'
+
+Autotest.add_hook :initialize do |at|
+  at.clear_mappings
+  # watch out: Ruby bug (1.8.6):
+  # %r(/) != /\//
+  at.add_mapping(%r%^examples/.*_example.rb$%) { |filename, _| 
+    filename 
+  }
+  at.add_mapping(%r%^lib/(.*)\.rb$%) { |filename, m| 
+    ["examples/lib/#{m[1]}_example.rb"]
+  }
+  at.add_mapping(%r%^examples/(example_helper|shared/.*)\.rb$%) { 
+    at.files_matching %r%^examples/.*_example\.rb$%
+  }
+end
+
+class MicronautCommandError < StandardError; end
+
+class Autotest::MicronautRails < Autotest
+
+  def initialize
+    super
+    self.failed_results_re = /^\d+\)\n(?:\e\[\d*m)?(?:.*?Error in )?'([^\n]*)'(?: FAILED)?(?:\e\[\d*m)?\n(.*?)\n\n/m
+    self.completed_re = /\n(?:\e\[\d*m)?\d* examples?/m
+  end
+  
+  def consolidate_failures(failed)
+    filters = new_hash_of_arrays
+    failed.each do |spec, trace|
+      if trace =~ /\n(\.\/)?(.*example\.rb):[\d]+:\Z?/
+        filters[$2] << spec
+      end
+    end
+    return filters
+  end
+
+  def make_test_cmd(files_to_test)
+    return '' if files_to_test.empty?
+    
+    examples = files_to_test.keys.flatten
+    
+    examples.map! {|f| %Q(require "#{f}")}
+
+    return "#{ruby} -e '#{examples.join("; ")}'"
+  end
+  
+end

data/lib/micronaut-rails.rb

@@ -0,0 +1,27 @@
+require 'action_controller'
+require 'action_controller/test_process'
+require 'micronaut/rails/configuration'
+require 'micronaut/rails/matchers/controllers/redirect_to'
+require 'micronaut/rails/matchers/controllers/render_template'
+require 'micronaut/rails/transactional_database_support'
+require 'micronaut/rails/version'
+require 'micronaut/rails/helpers'
+require 'micronaut/rails/controllers'
+require 'micronaut/rails/extensions/active_record'
+
+module Micronaut
+  module Rails
+    class IllegalDataAccessException < StandardError; end
+
+    def self.include_in(config)
+      if config.mock_framework.to_s =~ /mocha/i
+        require 'micronaut/rails/mocking/with_mocha'
+        Micronaut::Behaviour.send(:include, Micronaut::Rails::Mocking::WithMocha)
+      end
+      config.extend(Micronaut::Rails::TransactionalDatabaseSupport, :behaviour => { :describes => lambda { |dt| dt < ActiveRecord::Base } })
+      config.extend(Micronaut::Rails::Helpers, :behaviour => { :describes => lambda { |dt| dt.to_s.ends_with?('Helper') } })
+      config.extend(Micronaut::Rails::Controllers, :behaviour => { :describes => lambda { |dt| dt < ActionController::Base } })
+    end
+  end
+
+end

data/lib/micronaut/rails/configuration.rb

@@ -0,0 +1,57 @@
+module Micronaut
+  module Rails
+    
+    module Configuration
+      
+      def rails
+        self
+      end
+      
+      # :behaviour => { :describes => lambda { |dt| dt < ActiveRecord::Base }
+      def enable_active_record_transactional_support(filter_options={})
+        if filter_options.empty?
+          ::Micronaut::Behaviour.send(:extend, ::Micronaut::Rails::TransactionalDatabaseSupport)
+        else
+          ::Micronaut.config.extend(::Micronaut::Rails::TransactionalDatabaseSupport, filter_options)
+        end
+      end
+      
+      # :behaviour => { :describes => lambda { |dt| dt.to_s.ends_with?('Helper') }
+      def enable_helper_support(filter_options={})
+        if filter_options.empty?
+          ::Micronaut::Behaviour.send(:extend, ::Micronaut::Rails::Helpers)
+        else
+          ::Micronaut.config.extend(::Micronaut::Rails::Helpers, filter_options)
+        end 
+      end
+      
+      # :behaviour => { :describes => lambda { |dt| dt < ActionController::Base } 
+      def enable_controller_support(filter_options={})
+        if filter_options.empty?
+          ::Micronaut::Behaviour.send(:extend, ::Micronaut::Rails::Controllers)
+        else
+          ::Micronaut.config.extend(::Micronaut::Rails::Controllers, filter_options)
+        end
+      end
+      
+      def enable_rails_specific_mocking_extensions
+        case ::Micronaut.config.mock_framework.to_s
+        when /mocha/i
+          require 'micronaut/rails/mocking/with_mocha'
+          Micronaut::Behaviour.send(:include, Micronaut::Rails::Mocking::WithMocha)
+        end
+      end
+      
+      def enable_reasonable_defaults!
+        enable_active_record_transactional_support :describes => lambda { |dt| dt < ::ActiveRecord::Base }
+        enable_helper_support :describes => lambda { |dt| dt.to_s.ends_with?('Helper') }
+        enable_controller_support :describes => lambda { |dt| dt < ::ActionController::Base }
+        enable_rails_specific_mocking_extensions
+      end
+      
+    end
+    
+  end
+end
+
+::Micronaut::Configuration.send(:include, ::Micronaut::Rails::Configuration)

data/lib/micronaut/rails/controllers.rb

@@ -0,0 +1,106 @@
+module Micronaut
+  module Rails
+    module Controllers
+
+      module InstanceMethods
+        attr_reader :request, :response, :controller
+
+        def assert_routing(path, options, defaults={}, extras={}, message=nil)
+          method = options[:method] || :get
+          route_for(params_from(method, path)).should == path
+        end
+        
+        def route_for(options)
+          ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
+          ActionController::Routing::Routes.generate(options)
+        end
+
+        def params_from(method, path)
+          ActionController::Routing::Routes.reload if ActionController::Routing::Routes.empty?
+          ActionController::Routing::Routes.recognize_path(path, :method => method)
+        end
+          
+      end
+
+      module RenderOverrides
+        
+        def render_views!
+          @render_views = true
+        end
+
+        def render_views?
+          @render_views
+        end
+        
+        def render(options=nil, deprecated_status_or_extra_options=nil, &block)
+          if ::Rails::VERSION::STRING >= '2.0.0' && deprecated_status_or_extra_options.nil?
+            deprecated_status_or_extra_options = {}
+          end
+          # puts "\n[render(views => #{render_views?.inspect})] options => #{options.inspect}, caller => #{caller(0)[1]}"
+          response.headers['Status'] = interpret_status((options && options[:status]) || ::ActionController::Base::DEFAULT_RENDER_STATUS_CODE)
+                    
+          unless block_given?
+            unless render_views?
+              if @template.respond_to?(:finder)
+                (class << @template.finder; self; end).class_eval do
+                  define_method :file_exists? do; true; end
+                end
+              else
+                (class << @template; self; end).class_eval do
+                  define_method :file_exists? do; true; end
+                end
+              end
+              (class << @template; self; end).class_eval do
+
+                define_method :render_file do |*args|
+                  @first_render ||= args[0] unless args[0] =~ /^layouts/
+                  @_first_render ||= args[0] unless args[0] =~ /^layouts/
+                end
+
+                define_method :_pick_template do |*args|
+                  @_first_render ||= args[0] unless args[0] =~ /^layouts/
+                  PickedTemplate.new
+                end
+
+              end
+              
+            end
+          end     
+          
+          super(options, deprecated_status_or_extra_options, &block)
+        end
+
+      end
+
+      # Returned by _pick_template when running controller examples in isolation mode.
+      class PickedTemplate 
+        # Do nothing when running controller examples in isolation mode.
+        def render_template(*ignore_args); end
+        # Do nothing when running controller examples in isolation mode.
+        def render_partial(*ignore_args);  end
+      end
+
+      def self.extended(kls)
+        kls.send(:include, ActionController::TestProcess)
+        kls.send(:include, InstanceMethods)
+        kls.send(:include, Micronaut::Rails::Matchers::Controllers)
+
+        kls.before do
+          @controller.class.send :include, RenderOverrides
+          @controller.class.send :include, ActionController::TestCase::RaiseActionExceptions
+          @controller = self.class.describes.new
+          @request = ActionController::TestRequest.new
+          @controller.request = @request
+          @response = ActionController::TestResponse.new
+          @controller.params = {}
+          @controller.send(:initialize_current_url)
+          @response.session = @request.session
+        end
+
+
+
+      end
+
+    end
+  end
+end

data/lib/micronaut/rails/extensions/active_record.rb

@@ -0,0 +1,19 @@
+module Micronaut
+  module Rails
+    module Extensions
+      
+      module ActiveRecord
+        def errors_on(attribute)
+          self.valid?
+          [self.errors.on(attribute)].flatten.compact
+        end
+        alias :error_on :errors_on  
+      end
+      
+    end
+  end
+end
+
+if defined?(::ActiveRecord::Base)
+  ::ActiveRecord::Base.send(:include, Micronaut::Rails::Extensions::ActiveRecord)
+end

data/lib/micronaut/rails/helpers.rb

@@ -0,0 +1,99 @@
+module Micronaut
+  module Rails
+    module Helpers
+
+      class HelperController < ActionController::Base; end
+
+      module InstanceMethods
+
+        class HelperObject < ActionView::Base
+          def protect_against_forgery?
+            false
+          end
+
+          def session=(session)
+            @session = session
+          end
+
+          def request=(request)
+            @request = request
+          end
+
+          def flash=(flash)
+            @flash = flash
+          end
+
+          def params=(params)
+            @params = params
+          end
+
+          def controller=(controller)
+            @controller = controller
+          end
+
+          private
+          attr_reader :session, :request, :flash, :params, :controller
+        end
+
+        def helper
+          @helper_object ||= returning HelperObject.new do |helper_object|
+            if self.class.describes.class == Module
+              helper_object.extend self.class.describes
+            end
+          end
+        end
+
+        def params
+          request.parameters
+        end
+
+        def flash
+          response.flash
+        end
+
+        def session
+          response.session
+        end
+
+        def method_missing(sym, *args)
+          if helper.respond_to?(sym)
+            helper.send(sym, *args)
+          else
+            super
+          end
+        end
+
+      end
+
+      def self.extended(kls)
+        kls.send(:include, InstanceMethods)
+
+        kls.send(:attr_reader, :request, :response)
+
+        ActionView::Base.included_modules.reverse.each do |mod|
+          kls.send(:include, mod) if mod.parents.include?(ActionView::Helpers)
+        end
+
+        kls.before do
+          @controller = HelperController.new
+          @request = ActionController::TestRequest.new
+          @response = ActionController::TestResponse.new
+          @response.session = @request.session
+          @controller.request = @request
+          @flash = ActionController::Flash::FlashHash.new
+          @response.session['flash'] = @flash
+
+          ActionView::Helpers::AssetTagHelper::reset_javascript_include_default
+
+          helper.session = @response.session
+          helper.request = @request
+          helper.flash = @flash
+          helper.params = params
+          helper.controller = @controller
+        end
+
+      end
+
+    end
+  end
+end

data/lib/micronaut/rails/matchers/controllers/redirect_to.rb

@@ -0,0 +1,115 @@
+module Micronaut
+  module Rails
+    module Matchers
+      module Controllers
+
+        class RedirectTo  #:nodoc:
+
+          def initialize(request, expected)
+            @expected = expected
+            @request = request
+          end
+
+          def matches?(response)
+            @redirected = response.redirect?
+            @actual = response.redirect_url
+            return false unless @redirected
+            if @expected.instance_of? Hash
+              return false unless @actual =~ %r{^\w+://#{@request.host}}
+              return false unless actual_redirect_to_valid_route
+              return actual_hash == expected_hash
+            else
+              return @actual == expected_url
+            end
+          end
+
+          def actual_hash
+            hash_from_url @actual
+          end
+
+          def expected_hash
+            hash_from_url expected_url
+          end
+
+          def actual_redirect_to_valid_route
+            actual_hash
+          end
+
+          def hash_from_url(url)
+            query_hash(url).merge(path_hash(url)).with_indifferent_access
+          end
+
+          def path_hash(url)
+            path = url.sub(%r{^\w+://#{@request.host}(?::\d+)?}, "").split("?", 2)[0]
+            ActionController::Routing::Routes.recognize_path path
+          end
+
+          def query_hash(url)
+            query = url.split("?", 2)[1] || ""
+            QueryParameterParser.parse_query_parameters(query, @request)
+          end
+
+          def expected_url
+            case @expected
+            when Hash
+              return ActionController::UrlRewriter.new(@request, {}).rewrite(@expected)
+            when :back
+              return @request.env['HTTP_REFERER']
+            when %r{^\w+://.*}
+              return @expected
+            else
+              return "http://#{@request.host}" + (@expected.split('')[0] == '/' ? '' : '/') + @expected
+            end
+          end
+
+          def failure_message
+            if @redirected
+              return %Q{expected redirect to #{@expected.inspect}, got redirect to #{@actual.inspect}}
+            else
+              return %Q{expected redirect to #{@expected.inspect}, got no redirect}
+            end
+          end
+
+          def negative_failure_message
+            return %Q{expected not to be redirected to #{@expected.inspect}, but was} if @redirected
+          end
+
+          def description
+            "redirect to #{@actual.inspect}"
+          end
+
+          class QueryParameterParser
+            def self.parse_query_parameters(query, request)
+              if defined?(CGIMethods)
+                CGIMethods.parse_query_parameters(query)
+              else
+                request.class.parse_query_parameters(query)
+              end
+            end
+          end
+        end
+
+        # :call-seq:
+        #   response.should redirect_to(url)
+        #   response.should redirect_to(:action => action_name)
+        #   response.should redirect_to(:controller => controller_name, :action => action_name)
+        #   response.should_not redirect_to(url)
+        #   response.should_not redirect_to(:action => action_name)
+        #   response.should_not redirect_to(:controller => controller_name, :action => action_name)
+        #
+        # Passes if the response is a redirect to the url, action or controller/action.
+        # Useful in controller specs (integration or isolation mode).
+        #
+        # == Examples
+        #
+        #   response.should redirect_to("path/to/action")
+        #   response.should redirect_to("http://test.host/path/to/action")
+        #   response.should redirect_to(:action => 'list')
+        def redirect_to(opts)
+          RedirectTo.new(request, opts)
+        end
+
+      end
+    end
+  end
+end

data/lib/micronaut/rails/matchers/controllers/render_template.rb

@@ -0,0 +1,101 @@
+module Micronaut
+  module Rails
+    module Matchers
+      module Controllers
+
+        class RenderTemplate #:nodoc:
+
+          def initialize(expected, controller)
+            @controller = controller
+            @expected = expected
+          end
+
+          def matches?(response)
+            if response.respond_to?(:rendered_file)
+              @actual = response.rendered_file
+            else
+              @actual = response.rendered_template.to_s
+            end
+            return false if @actual.blank?
+            given_controller_path, given_file = path_and_file(@actual)
+            expected_controller_path, expected_file = path_and_file(@expected)
+            given_controller_path == expected_controller_path && given_file.match(expected_file)
+          end
+
+          def failure_message
+            "expected #{@expected.inspect}, got #{@actual.inspect}"
+          end
+
+          def negative_failure_message
+            "expected not to render #{@expected.inspect}, but did"
+          end
+
+          def description
+            "render template #{@expected.inspect}"
+          end
+
+          private
+          def path_and_file(path)
+            parts = path.split('/')
+            file = parts.pop
+            controller = parts.empty? ? current_controller_path : parts.join('/')
+            return controller, file
+          end
+
+          def controller_path_from(path)
+            parts = path.split('/')
+            parts.pop
+            parts.join('/')
+          end
+
+          def current_controller_path
+            @controller.class.to_s.underscore.gsub(/_controller$/,'')
+          end
+
+        end
+
+        # :call-seq:
+        #   response.should render_template(template)
+        #   response.should_not render_template(template)
+        #
+        # For use in controller code examples (integration or isolation mode).
+        #
+        # Passes if the specified template (view file) is rendered by the
+        # response. This file can be any view file, including a partial. However
+        # if it is a partial it must be rendered directly i.e. you can't detect
+        # that a partial has been rendered as part of a view using
+        # render_template. For that you should use a message expectation
+        # (mock) instead:
+        #
+        #   controller.should_receive(:render).with(:partial => 'path/to/partial')
+        #
+        # <code>template</code> can include the controller path. It can also
+        # include an optional extension, which you only need to use when there
+        # is ambiguity.
+        #
+        # Note that partials must be spelled with the preceding underscore.
+        #
+        # == Examples
+        #
+        #   response.should render_template('list')
+        #   response.should render_template('same_controller/list')
+        #   response.should render_template('other_controller/list')
+        #
+        #   # with extensions
+        #   response.should render_template('list.rjs')
+        #   response.should render_template('list.haml')
+        #   response.should render_template('same_controller/list.rjs')
+        #   response.should render_template('other_controller/list.rjs')
+        #
+        #   # partials
+        #   response.should render_template('_a_partial')
+        #   response.should render_template('same_controller/_a_partial')
+        #   response.should render_template('other_controller/_a_partial')
+        def render_template(path)
+          RenderTemplate.new(path.to_s, @controller)
+        end
+
+      end
+    end
+  end
+end

data/lib/micronaut/rails/mocking/with_mocha.rb

@@ -0,0 +1,89 @@
+module Micronaut
+  module Rails
+    module Mocking
+      module WithMocha
+
+        module ModelStubber
+
+          def connection
+            raise MicronautRails::IllegalDataAccessException.new("stubbed models are not allowed to access the database")
+          end
+
+          def new_record?
+            id.nil?
+          end
+
+          def as_new_record
+            self.id = nil
+            self
+          end
+
+        end
+
+        def stub_model(model_class, params = {})
+          params = params.dup
+          model = model_class.new
+          model.id = params.delete(:id) || next_id
+
+          model.extend ModelStubber
+          params.keys.each do |prop|
+            model[prop] = params.delete(prop) if model.has_attribute?(prop)
+          end
+          add_stubs(model, params)
+
+          yield model if block_given?
+          model
+        end
+
+        # Stubs methods on +object+ (if +object+ is a symbol or string a new mock
+        # with that name will be created). +stubs+ is a Hash of +method=>value+
+        def add_stubs(object, params) # :nodoc:
+          m = [String, Symbol].include?(object.class) ? mock(object.to_s) : object
+          params.each { |prop, value| m.stubs(prop).returns(value) }
+          m
+        end
+
+        def mock_model(model_class, params = {})
+          id = params[:id] || next_id
+          model = stub("#{model_class.name}_#{id}", {
+            :id => id,
+            :to_param => id.to_s,
+            :new_record? => false,
+            :errors => stub("errors", :count => 0)
+            }.update(params))
+
+            model.instance_eval <<-CODE
+            def as_new_record
+              self.stubs(:id).returns(nil)
+              self.stubs(:to_param).returns(nil)
+              self.stubs(:new_record?).returns(true)
+              self
+            end
+            def is_a?(other)
+              #{model_class}.ancestors.include?(other)
+            end
+            def kind_of?(other)
+              #{model_class}.ancestors.include?(other)
+            end
+            def instance_of?(other)
+              other == #{model_class}
+            end
+            def class
+              #{model_class}
+            end
+            CODE
+
+            yield model if block_given?
+            return model
+          end
+
+          private
+          @@model_id = 1000
+          def next_id
+            @@model_id += 1
+          end
+
+      end
+    end
+  end
+end

data/lib/micronaut/rails/transactional_database_support.rb

@@ -0,0 +1,39 @@
+module Micronaut
+  module Rails
+    module TransactionalDatabaseSupport
+
+      module InstanceMethods
+
+        def active_record_configured?
+          defined?(ActiveRecord) && !ActiveRecord::Base.configurations.blank?
+        end
+
+        def transactional_protection_start
+          return unless active_record_configured?
+
+          ActiveRecord::Base.connection.increment_open_transactions
+          ActiveRecord::Base.connection.begin_db_transaction
+        end
+
+        def transactional_protection_cleanup
+          return unless active_record_configured?
+
+          if ActiveRecord::Base.connection.open_transactions != 0
+            ActiveRecord::Base.connection.rollback_db_transaction
+            ActiveRecord::Base.connection.decrement_open_transactions
+          end
+
+          ActiveRecord::Base.clear_active_connections!
+        end
+
+      end
+
+      def self.extended(kls)
+        kls.send(:include, InstanceMethods)
+        kls.before { transactional_protection_start }
+        kls.after { transactional_protection_cleanup }
+      end
+
+    end
+  end
+end

data/lib/micronaut/rails/version.rb

@@ -0,0 +1,14 @@
+module Micronaut
+  module Rails
+    module Version
+      MAJOR = 0
+      MINOR = 0
+      TINY  = 6
+      MINISCULE = 1
+      
+      STRING = [MAJOR, MINOR, TINY, MINISCULE].join('.')
+      
+      MICRONAUT_REQUIRED_VERSION = ">= 0.1.6"
+    end
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification 
+name: spicycode-micronaut-rails
+version: !ruby/object:Gem::Version 
+  version: 0.0.6.1
+platform: ruby
+authors: 
+- Chad Humphries
+autorequire: micronaut-rails
+bindir: bin
+cert_chain: []
+
+date: 2008-12-27 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: actionpack
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.2.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: spicycode-micronaut
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.1.6
+    version: 
+description: An excellent replacement for the wheel...
+email: chad@spicycode.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- RSPEC-LICENSE
+files: 
+- LICENSE
+- README
+- RSPEC-LICENSE
+- Rakefile
+- lib/autotest
+- lib/autotest/discover.rb
+- lib/autotest/micronaut-rails.rb
+- lib/autotest/micronaut_rails.rb
+- lib/micronaut
+- lib/micronaut/rails
+- lib/micronaut/rails/configuration.rb
+- lib/micronaut/rails/controllers.rb
+- lib/micronaut/rails/extensions
+- lib/micronaut/rails/extensions/active_record.rb
+- lib/micronaut/rails/helpers.rb
+- lib/micronaut/rails/matchers
+- lib/micronaut/rails/matchers/controllers
+- lib/micronaut/rails/matchers/controllers/redirect_to.rb
+- lib/micronaut/rails/matchers/controllers/render_template.rb
+- lib/micronaut/rails/mocking
+- lib/micronaut/rails/mocking/with_mocha.rb
+- lib/micronaut/rails/transactional_database_support.rb
+- lib/micronaut/rails/version.rb
+- lib/micronaut-rails.rb
+- examples/example_helper.rb
+- examples/lib
+- examples/lib/micronaut
+- examples/lib/micronaut/rails
+- examples/lib/micronaut/rails/configuration_example.rb
+- examples/lib/micronaut-rails_example.rb
+has_rdoc: true
+homepage: http://spicycode.com
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: An excellent replacement for the wheel...
+test_files: []
+