radiant 0.8.2 → 0.9.0.rc2

data/spec/lib/radiant/extension_loader_spec.rb

@@ -13,7 +13,7 @@ describe Radiant::ExtensionLoader do
     @instance = Radiant::ExtensionLoader.send(:new)
     @instance.initializer = @initializer
 
-    @extensions = %w{01_basic 02_overriding load_order_blue load_order_green load_order_red}
+    @extensions = %w{basic overriding load_order_blue load_order_green load_order_red}
     @extension_paths = @extensions.map do |ext|
       File.expand_path("#{RADIANT_ROOT}/test/fixtures/extensions/#{ext}")
     end
@@ -32,7 +32,14 @@ describe Radiant::ExtensionLoader do
   it "should only load extensions specified in the configuration" do
     @configuration.should_receive(:extensions).at_least(:once).and_return([:basic])
     @instance.stub!(:all_extension_roots).and_return(@extension_paths)
-    @instance.send(:select_extension_roots).should == [File.expand_path("#{RADIANT_ROOT}/test/fixtures/extensions/01_basic")]
+    @instance.send(:select_extension_roots).should == [File.expand_path("#{RADIANT_ROOT}/test/fixtures/extensions/basic")]
+  end
+
+  it "should load gem extensions with paths matching radiant-*-extension" do
+    gem_path = File.join RADIANT_ROOT, %w(test fixtures gems radiant-gem_ext-extension-0.0.0)
+    @configuration.should_receive(:extensions).at_least(:once).and_return([:gem_ext])
+    @instance.stub!(:all_extension_roots).and_return([File.expand_path(gem_path)])
+    @instance.send(:select_extension_roots).should == [gem_path]
   end
 
   it "should select extensions in an explicit order from the configuration" do
@@ -58,6 +65,12 @@ describe Radiant::ExtensionLoader do
     lambda { @instance.send(:select_extension_roots) }.should raise_error(LoadError)
   end
 
+  it "should skip invalid gems" do
+    @configuration.stub!(:extension_paths).and_return([])
+    @configuration.stub!(:gems).and_return([Rails::GemDependency.new('bogus_gem')])
+    @instance.send(:all_extension_roots).should eql([])
+  end
+
   it "should determine load paths from an extension path" do
     @instance.send(:load_paths_for, "#{RADIANT_ROOT}/vendor/extensions/archive").should == %W{
         #{RADIANT_ROOT}/vendor/extensions/archive/lib
@@ -132,12 +145,19 @@ describe Radiant::ExtensionLoader do
     @instance.metal_paths.all? {|f| File.directory?(f) }.should be_true
   end
 
+  it "should have locale paths" do
+    @instance.stub!(:load_extension_roots).and_return(@extension_paths)
+    @instance.should respond_to(:locale_paths)
+    @instance.metal_paths.should be_instance_of(Array)
+    @instance.metal_paths.all? {|f| File.directory?(f) }.should be_true
+  end
+
   it "should return the view paths in inverse order to the loaded" do
     extensions = [BasicExtension, OverridingExtension]
     @instance.extensions = extensions
     @instance.view_paths.should == [
-       "#{RADIANT_ROOT}/test/fixtures/extensions/02_overriding/app/views",
-       "#{RADIANT_ROOT}/test/fixtures/extensions/01_basic/app/views"
+       "#{RADIANT_ROOT}/test/fixtures/extensions/overriding/app/views",
+       "#{RADIANT_ROOT}/test/fixtures/extensions/basic/app/views"
       ]
   end
 
@@ -146,8 +166,8 @@ describe Radiant::ExtensionLoader do
     extensions = [BasicExtension, OverridingExtension]
     @instance.extensions = extensions
     @instance.metal_paths.should == [
-       "#{RADIANT_ROOT}/test/fixtures/extensions/02_overriding/app/metal",
-       "#{RADIANT_ROOT}/test/fixtures/extensions/01_basic/app/metal"
+       "#{RADIANT_ROOT}/test/fixtures/extensions/overriding/app/metal",
+       "#{RADIANT_ROOT}/test/fixtures/extensions/basic/app/metal"
       ]
   end
   
@@ -155,12 +175,22 @@ describe Radiant::ExtensionLoader do
     @instance.should_receive(:load_extension_roots).and_return(@extension_paths)
     @instance.load_extensions
     @extensions.each do |ext|
-      ext_class = Object.const_get(ext.gsub(/^\d+_/, '').camelize + "Extension")
+      ext_class = Object.const_get(ext.camelize + "Extension")
       ext_class.should_not be_nil
       ext_class.root.should_not be_nil
     end
   end
 
+  it "should load extensions from gem paths" do
+    # Mock gem loading
+    gem_path = File.expand_path(File.join(RADIANT_ROOT, %w(test fixtures gems radiant-gem_ext-extension-0.0.0)))
+    $: << gem_path
+    require 'gem_ext_extension'
+    @instance.should_receive(:load_extension_roots).and_return([gem_path])
+
+    @instance.load_extensions.should include(GemExtExtension)
+  end
+
   it "should deactivate extensions" do
     extensions = [BasicExtension, OverridingExtension]
     @instance.extensions = extensions

data/spec/lib/radiant/extension_spec.rb

@@ -25,7 +25,20 @@ describe Radiant::Extension do
   end
   
   it "should have a migrations path" do
-    BasicExtension.migrations_path.should == "#{RADIANT_ROOT}/test/fixtures/extensions/01_basic/db/migrate"
+    BasicExtension.migrations_path.should == "#{RADIANT_ROOT}/test/fixtures/extensions/basic/db/migrate"
+  end
+  
+  describe BasicExtension do
+    its(:routing_file) { should match '/extensions/basic/config/routes.rb' }
+  end
+  
+  context "when the routing_file exists" do
+    subject { RoutedExtension }
+    it { should be_routed }
+  end
+  context "when the routing_file does not exist" do
+    subject { BasicExtension }
+    it { should_not be_routed }
   end
   
   it "should set the extension_name in subclasses" do
@@ -47,6 +60,24 @@ describe Radiant::Extension do
     end
   end
 
+  it "should allow the manipulation of tabs" do
+    BasicExtension.admin.nav['Design'].length.should == 2
+    BasicExtension.class_eval {
+      tab 'Design' do
+        add_item "Pages", "/admin/pages"
+      end
+    }
+    BasicExtension.admin.nav['Design'].length.should == 3
+  end
+  
+  it "should allow the addition of tabs" do
+    start_length = BasicExtension.admin.nav.length
+    BasicExtension.class_eval {
+      tab 'Additional'
+    }
+    BasicExtension.admin.nav.length.should == start_length + 1
+  end
+
   describe ".extension_enabled?" do
     it "should be false if extension does not exist" do
       BasicExtension.extension_enabled?(:bogus).should be_false

data/spec/lib/radiant/initializer_spec.rb

@@ -70,6 +70,30 @@ describe Radiant::Configuration do
       @configuration.check_extension_dependencies
     }.should raise_error(SystemExit)
   end
+
+  describe "#all_available_extensions" do
+    before do
+      @spec = mock(Gem::Specification)
+      @gem = mock(Rails::GemDependency, :specification => @spec)
+      @configuration.gems = [@gem]
+    end
+
+    it "should not load gems that don't follow extension conventions" do
+      @spec.stub!(:full_gem_path).and_return(File.join(RADIANT_ROOT, %w(test fixtures gems misnamed_ext-0.0.0)))
+      available_extensions = @configuration.all_available_extensions.map(&:to_s)
+      available_extensions.grep(/misnamed_ext/).should be_empty
+    end
+
+    it "should skip gems with invalid specifications" do
+      @configuration.gems = [Rails::GemDependency.new('bogus_gem')]
+      @configuration.all_available_extensions.should_not include(:bogus_gem)
+    end
+
+    it "should load gems matching radiant-*-extension" do
+      @spec.stub!(:full_gem_path).and_return(File.join(RADIANT_ROOT, %w(test fixtures gems radiant-gem_ext-extension-0.0.0)))
+      @configuration.all_available_extensions.should include(:gem_ext)
+    end
+  end
 end
 
 describe Radiant::Initializer do
@@ -110,8 +134,8 @@ describe Radiant::Initializer do
   end
   
   it "should initialize admin tabs" do
+    Radiant::AdminUI.instance.should_receive(:load_default_nav)
     @initializer.initialize_default_admin_tabs
-    Radiant::AdminUI.instance.tabs.size.should == 3
   end
   
   it "should have access to the AdminUI" do
@@ -119,7 +143,7 @@ describe Radiant::Initializer do
   end
 
   it "should load metal from RADIANT_ROOT and exensions" do
-    Rails::Rack::Metal.metal_paths.should == ["#{RADIANT_ROOT}/app/metal", "#{RADIANT_ROOT}/test/fixtures/extensions/02_overriding/app/metal", "#{RADIANT_ROOT}/test/fixtures/extensions/01_basic/app/metal"]
+    Rails::Rack::Metal.metal_paths.should == ["#{RADIANT_ROOT}/app/metal", "#{RADIANT_ROOT}/test/fixtures/extensions/overriding/app/metal", "#{RADIANT_ROOT}/test/fixtures/extensions/basic/app/metal"]
   end
 
   it "should check dependent extensions" do
@@ -128,4 +152,10 @@ describe Radiant::Initializer do
     @initializer.after_initialize
   end
 
+  it "should remove extension gem paths from ActiveSupport::Dependencies" do
+    load_paths = [File.join(RADIANT_ROOT, %w(test fixtures gems radiant-gem_ext-extension-0.0.0 lib))]
+    @loader.stub!(:extension_load_paths).and_return(load_paths)
+    ActiveSupport::Dependencies.load_once_paths.should_receive(:-).with(load_paths)
+    @initializer.add_plugin_load_paths
+  end
 end

data/spec/lib/radiant/taggable_spec.rb

@@ -28,10 +28,10 @@ describe Radiant::Taggable, "when included in a class or module" do
     TaggedClass.new.send("tag:hello").should == "hello world"
   end
   
-  it "should store tag descriptions filtered with Textile" do
+  it "should store tag descriptions filtered without Textile, so that translations can be applied" do
     [TaggedClass, TaggedModule].each do |c|
       c.desc "A simple tag."
-      Radiant::Taggable.last_description.should == "<p>A simple tag.</p>"
+      Radiant::Taggable.last_description.should == "A simple tag."
     end
   end
   
@@ -46,12 +46,14 @@ describe Radiant::Taggable, "when included in a class or module" do
     end
   end
   
-  it "should normalize leading whitespace in a tag description" do
-    Radiant::Taggable::Util.should_receive(:strip_leading_whitespace).twice.with("   Blah blah\n blah blah").and_return("blah")
-    [TaggedClass, TaggedModule].each do |c|
-      c.desc "   Blah blah\n blah blah"
-    end
-  end
+  # This has been moved to the admin/references_helper
+  #
+  # it "should normalize leading whitespace in a tag description" do
+  #   Radiant::Taggable::Util.should_receive(:strip_leading_whitespace).twice.with("   Blah blah\n blah blah").and_return("blah")
+  #   [TaggedClass, TaggedModule].each do |c|
+  #     c.desc "   Blah blah\n blah blah"
+  #   end
+  # end
 end
 
 describe Radiant::Taggable, "when included in a module with defined tags" do

data/spec/lib/radiant_spec.rb

@@ -18,9 +18,13 @@ describe Radiant::Version do
   it "should have a constant for the tiny revision" do
     lambda { Radiant::Version::Tiny }.should_not raise_error(NameError)
   end
+
+  it "should have a constant for the patch revision" do
+    lambda { Radiant::Version::Patch }.should_not raise_error(NameError)
+  end
   
   it "should join the revisions into the version number" do
     Radiant::Version.to_s.should be_kind_of(String)
-    Radiant::Version.to_s.should == [Radiant::Version::Major, Radiant::Version::Minor, Radiant::Version::Tiny].join(".") 
+    Radiant::Version.to_s.should == [Radiant::Version::Major, Radiant::Version::Minor, Radiant::Version::Tiny, Radiant::Version::Patch].join(".") 
   end
 end

data/spec/lib/task_support_spec.rb

@@ -39,4 +39,35 @@ describe TaskSupport do
       Radiant::Config.to_hash.should == YAML.load(YAML.load_file(@yaml_file))
     end
   end
+
+  describe "self.cache_files" do
+    before do
+      @files = [ 'a.txt', 'b.txt' ]
+      @dir = "#{Rails.root}/tmp/cache_files_test"
+      @cache_file = 'all.txt'
+
+      FileUtils.mkdir_p(@dir)
+      FileUtils.rm_rf(File.join(@dir, '*.txt'))
+      @files.each do |f_name|
+        File.open(File.join(@dir, f_name), "w+") do |f|
+          f.write("Contents of '#{f_name}'")
+        end
+      end
+    end
+
+    it "should create a cache file containing the contents of the specified files" do
+      TaskSupport.cache_files(@dir, @files, @cache_file)
+      cache_path = File.join(@dir, @cache_file)
+      File.should exist(cache_path)
+      File.read(cache_path).should == "Contents of 'a.txt'\n\nContents of 'b.txt'"
+    end
+  end
+
+  describe "self.find_admin_js" do
+    it "should return an array of JS files" do
+      js_files = TaskSupport.find_admin_js
+      js_files.should_not be_empty
+      js_files.each { |f| f.should =~ /^[^\/]+.js$/ }
+    end
+  end
 end

data/spec/lib/translation_support_spec.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe TranslationSupport do
+  describe 'self.get_translation_keys' do
+    before do
+      @language_root = RADIANT_ROOT + '/test/fixtures/extensions/locale/config/locales'
+    end
+    it "should return the word set for the given language root" do
+      TranslationSupport.get_translation_keys(@language_root).should == {"base:test"=>" 'yes!'"}
+    end
+    it "should return the word set for the given language root and suffix" do
+      suffix = '-uk'
+      TranslationSupport.get_translation_keys(@language_root, suffix).should == {"base:test"=>" 'UK!'"}
+    end
+  end
+end

data/spec/matchers/generator_matchers.rb

@@ -2,236 +2,234 @@ module Spec
   module Matchers
     module GeneratorMatchers
       class DirectoryGenerated
-        def initialize(dir)
-          @dir = dir
-        end
-        
+        def initialize(dir)             @dir = dir end
+        def failure_message()           "expected directory '#{@path}' should exist but doesn't" end
+        def negative_failure_message()  "expected no directory, but directory '#{@path}' was found" end
+      
         def matches?(base)
           @base = base
           @path = File.join(RADIANT_ROOT, @base, @dir)
           File.exist?(@path) && File.directory?(@path)
         end
-        
-        def failure_message
-          "expected directory '#{@path}' should exist but doesn't"
-        end
-        
-        def negative_failure_message
-           "expected no directory, but directory '#{@path}' was found"
-        end
-      end
-      
-      def have_generated_directory(dir)
-        FileGenerated.new(dir)
       end
-      
+    
       class FileGenerated
-        def initialize(file, &block)
-          @file = file
-          @match_block = block if block_given?
-        end
-        
+        def initialize(file)            @file = file end
+        def failure_message()           "expected file '#{@path}' should exist but doesn't" end
+        def negative_failure_message()  "expected no file, but file '#{@path}' was found" end
+      
         def matches?(base)
           @base = base
           @path = File.join(RADIANT_ROOT, @base, @file)
-          if @match_block
-            contents_match = File.open(@path) do |f|
-              @match_block.call(f.read)
-            end
-            contents_match && file_exists(@path)
-          else
-            file_exists(@path)
+          if (exists = File.exist?(@path)) && block_given?  
+            File.open(@path) { |f| yield(f.read) }
           end
-        end
-        
-        def failure_message
-          "expected file '#{@path}' should exist but doesn't"
-        end
-        
-        def negative_failure_message
-           "expected no file, but file '#{@path}' was found"
-        end
-        
-        def file_exists(path)
-          File.exist?(path)
+          return exists
         end
       end
       
-      def have_generated_file(file, &block)
-        FileGenerated.new(file, &block)
+      class YamlGenerated
+        def initialize(path)            @path = path end
+        def failure_message()           "the file '#{@path}.yml' should be a YAML file" end
+        def negative_failure_message()  "expected no file, but file '#{@path}.yml' was found" end
+        
+        def matches?(base)
+          FileGenerated.new("#{@path}.yml").matches?(base) do |body|
+            yield(YAML.load(body.to_s)) if block_given?
+            return true
+          end
+          false
+        end
       end
       
-      def have_generated_class(path, parent = nil)
-        simple_matcher "directory contains generated class file" do |dir, matcher|
-          matcher.failure_message = "the file '#{path}.rb' should be a class"
-          
-          if path.split('/').size > 3
-            path =~ /\/?(\d+_)?(\w+)\/(\w+)$/
+      class ClassGenerated
+        def initialize(path, parent=nil)  @path = path; @parent = parent; end
+        def failure_message()             "the file '#{@path}.rb' should be a class" end
+        def negative_failure_message()    "expected no file, but file '#{@path}.rb' was found" end
+        
+        def matches?(base)
+          if @path.split('/').size > 3
+            @path =~ /\/?(\d+_)?(\w+)\/(\w+)$/
             class_name = "#{$2.camelize}::#{$3.camelize}"
           else
-            path =~ /\/?(\d+_)?(\w+)$/
+            @path =~ /\/?(\d+_)?(\w+)$/
             class_name = $2.camelize
           end
           
-          dir.should have_generated_file("#{path}.rb") do |body|
-            body.should match(/class #{class_name}#{parent.nil? ? '':" < #{parent}"}\n((\n|\s*.*\n)*)end/)
-            yield $1 if block_given?
+          FileGenerated.new("#{@path}.rb").matches?(base) do |body|
+            match_data = body.match(/class #{class_name}#{@parent.nil? ? '':" < #{@parent}"}\n((\n|\s*.*\n)*)end/)
+            yield(match_data[1]) if block_given? && !!match_data
+            return !!match_data
           end
+          false
         end
       end
       
-      def have_generated_module(path, parent = nil)
-        simple_matcher "directory contains generated class file" do |dir, matcher|
-          matcher.failure_message = "the file '#{path}.rb' should be a module"
-          
-          if path.split('/').size > 3
-            path =~ /\/?(\d+_)?(\w+)\/(\w+)$/
+      class ModuleGenerated
+        def initialize(path, parent=nil)  @path = path; @parent = parent; end
+        def failure_message()             "the file '#{@path}.rb' should be a module" end
+        def negative_failure_message()    "expected no file, but file '#{@path}.rb' was found" end
+        
+        def matches?(base)
+          if @path.split('/').size > 3
+            @path =~ /\/?(\d+_)?(\w+)\/(\w+)$/
             module_name = "#{$2.camelize}::#{$3.camelize}"
           else
-            path =~ /\/?(\d+_)?(\w+)$/
+            @path =~ /\/?(\d+_)?(\w+)$/
             module_name = $2.camelize
           end
           
-          dir.should have_generated_file("#{path}.rb") do |body|
-            body.should match(/module #{module_name}#{parent.nil? ? '':" < #{parent}"}\n((\n|\s*.*\n)*)end/)
-            yield $1 if block_given?
+          FileGenerated.new("#{@path}.rb").matches?(base) do |body|
+            match_data = body.match(/module #{module_name}#{@parent.nil? ? '':" < #{@parent}"}\n((\n|\s*.*\n)*)end/)
+            yield(match_data[1]) if block_given? && !!match_data
+            return !!match_data
           end
+          false
         end
       end
       
-      def have_generated_spec(path, class_name = true)
-        simple_matcher "directory contains generated model spec" do |dir, matcher|
-          matcher.failure_message = "the file '#{path}.rb' should be a spec"
-          
-          if path.split('/').size > 3
-            path =~ /\/?(\d+_)?(\w+)\/(\w+)$/
-            class_name = "#{$2.camelize}::#{$3.camelize}"
-          else
-            path =~ /\/?(\d+_)?(\w+)$/
-            class_name = $2.camelize
+      class SpecGenerated
+        def initialize(path, class_name=true) @path = path; @class_name = class_name; end
+        def failure_message()                 "the file '#{@path}.rb' should be a spec" end
+        def negative_failure_message()        "expected no file, but file '#{@path}.rb' was found" end
+        
+        def matches?(base)
+          unless @class_name == false
+            if @path.split('/').size > 3
+              @path =~ /\/?(\d+_)?(\w+)\/(\w+)$/
+              @class_name = "#{$2.camelize}::#{$3.camelize}"
+            else
+              @path =~ /\/?(\d+_)?(\w+)$/
+              @class_name = $2.camelize
+            end
           end
           
-          dir.should have_generated_file("#{path}_spec.rb") do |body|
-            if class_name
-              body.should match(/describe #{class_name} do\n((\s*.*\n)+)\nend/)
-              yield $1 if block_given?
+          FileGenerated.new("#{@path}_spec.rb").matches?(base) do |body|
+            if @class_name
+              match_data = body.match(/describe #{@class_name} do\n((\s*.*\n)+)\s*end/)
+              yield(match_data[1]) if block_given? && !!match_data
+              return !!match_data
             else
-              yield body if block_given?
+              yield(body) if block_given?
+              return true
             end
           end
+          false
         end
       end
       
-      def have_generated_controller_for(name, parent = "ApplicationController")
-        have_generated_class "app/controllers/#{name.to_s.underscore}_controller", parent do |body|
-          yield body if block_given?
+      class MigrationGenerated
+        def initialize(name, parent="ActiveRecord::Migration")  @name = name; @parent = parent; end
+        def failure_message()                                   "the file '#{@path}' should be a spec" end
+        def negative_failure_message()                          "expected no file, but file '#{@path}.rb' was found" end
+        
+        def matches?(base)
+          root_path = File.expand_path(File.join(RADIANT_ROOT, base))
+          @path = Dir.glob("#{root_path}/db/migrate/*_#{@name.to_s.underscore}.rb").first
+          return false if @path.nil?
+          @path = @path.match(/db\/migrate\/[0-9]+_\w+/).to_s
+          
+          ClassGenerated.new(@path, @parent).matches?(base) do |body|
+            yield(body) if block_given?
+            return true
+          end
+          false
         end
       end
       
-      def have_generated_model_for(name, parent = "ActiveRecord::Base")
-        have_generated_class "app/models/#{name.to_s.underscore}", parent do |body|
-          yield body if block_given?
+      class MethodMatcher
+        def initialize(name)            @name = name end
+        def failure_message()           "the string should contain a method definition for #{@name}" end
+        def negative_failure_message()  "expected no method definition for #{@name}, but found it" end
+        
+        def matches?(actual)
+          match_data = actual.match(/^\s*def #{@name}(\(.+\))?\n((\n|\s+.*\n)*)\s*end/)
+          if !!match_data && block_given?
+            yield(match_data[2])
+          end
+          return !!match_data
         end
+      end      
+      
+      def have_generated_directory(dir)
+        DirectoryGenerated.new(dir)
+      end
+      
+      def have_generated_file(file)
+        FileGenerated.new(file)
+      end
+      
+      def have_generated_class(path, parent = nil)
+        ClassGenerated.new(path, parent)
+      end
+      
+      def have_generated_module(path, parent = nil)
+        ModuleGenerated.new(path, parent)
+      end
+      
+      def have_generated_spec(path, class_name = true)
+        SpecGenerated.new(path, class_name)
+      end
+      
+      def have_generated_controller_for(name, parent = "ApplicationController")
+        ClassGenerated.new("app/controllers/#{name.to_s.underscore}_controller", parent)
+      end
+      
+      def have_generated_model_for(name, parent = "ActiveRecord::Base")
+        ClassGenerated.new("app/models/#{name.to_s.underscore}", parent)
       end
       
       def have_generated_model_spec_for(name)
-        have_generated_spec "spec/models/#{name.to_s.underscore}" do |body|
-          yield body if block_given?
-        end
+        SpecGenerated.new("spec/models/#{name.to_s.underscore}")
       end
       
       def have_generated_controller_spec_for(name)
-        have_generated_spec "spec/controllers/#{name.to_s.underscore}_controller" do |body|
-          yield body if block_given?
-        end
+        SpecGenerated.new("spec/controllers/#{name.to_s.underscore}_controller")
       end
       
       def have_generated_helper_spec_for(name)
-        have_generated_spec "spec/helpers/#{name.to_s.underscore}_helper" do |body|
-          yield body if block_given?
-        end
+        SpecGenerated.new("spec/helpers/#{name.to_s.underscore}_helper")
       end
       
-      def have_generated_view_specs_for(name, *actions)
-        simple_matcher "directory should contain generated view specs" do |dir, matcher|
-          actions.each do |action|
-            dir.should have_generated_spec("spec/views/#{name.to_s.underscore}/#{action.to_s.underscore}_view", false) do |body|
-              yield body if block_given?
-            end
-          end
-        end
+      def have_generated_view_spec_for(controller, action)
+        SpecGenerated.new("spec/views/#{controller.to_s.underscore}/#{action.to_s.underscore}_view", false)
       end
       
       def have_generated_helper_for(name)
-        have_generated_module "app/helpers/#{name.to_s.underscore}_helper" do |body|
-          yield body if block_given?
-        end
+        ModuleGenerated.new("app/helpers/#{name.to_s.underscore}_helper")
       end
       
       def have_generated_functional_test_for(name, parent = "ActionController::TestCase")
-        have_generated_class "test/functional/#{name.to_s.underscore}_controller_test", parent do |body|
-          yield body if block_given?
-        end
+        ClassGenerated.new("test/functional/#{name.to_s.underscore}_controller_test", parent)
       end
       
       def have_generated_unit_test_for(name, parent = "ActiveSupport::TestCase")
-        have_generated_class "test/unit/#{name.to_s.underscore}_test", parent do |body|
-          yield body if block_given?
-        end
+        ClassGenerated.new("test/unit/#{name.to_s.underscore}_test", parent)
       end
       
       def have_generated_migration(name, parent = "ActiveRecord::Migration")
-        simple_matcher 'directory should contain migration file' do |dir, matcher|
-          root_path = File.expand_path(File.join(RADIANT_ROOT, dir))
-          file = Dir.glob("#{root_path}/db/migrate/*_#{name.to_s.underscore}.rb").first
-          file = file.match(/db\/migrate\/[0-9]+_\w+/).to_s
-          dir.should have_generated_class(file, parent) do |body|
-            yield body if block_given?
-          end
-        end
+        MigrationGenerated.new(name, parent)
       end
       
       def have_generated_yaml(path)
-        simple_matcher "directory contains generated YAML file" do |dir, matcher|
-          dir.should have_generated_file("#{path}.yml") do |body|
-            yaml = YAML.load(body.to_s)
-            yaml.should be
-            yield yaml if block_given?
-          end
-        end
+        YamlGenerated.new(path)
       end
       
       def have_generated_fixtures_for(name)
-        have_generated_yaml "test/fixtures/#{name.to_s.underscore}" do |yaml|
-          yield yaml if block_given?
-        end
+        YamlGenerated.new("test/fixtures/#{name.to_s.underscore}")
       end
       
-      def have_generated_views_for(name, actions, suffix = "html.erb")
-        simple_matcher "directory should contain generated views" do |dir, matcher|
-          actions.each do |action|
-            have_generated_file("app/views/#{name.to_s.underscore}/#{action}.#{suffix}") do |body|
-              yield body if block_given?
-            end
-          end
-        end
+      def have_generated_view_for(name, action, suffix = "html.erb")
+        FileGenerated.new("app/views/#{name.to_s.underscore}/#{action}.#{suffix}")
       end
       
-      def have_methods(*methods)
-        simple_matcher "file body contains generated method definition" do |body, matcher|
-          methods.each do |name|
-            body.should match(/^  def #{name}(\(.+\))?\n((\n|   .*\n)*)  end/)
-            yield(name, $2) if block_given?
-          end
-        end
+      def have_method(name)
+        MethodMatcher.new(name)
       end
       
       def have_generated_column(name, type)
-        simple_matcher "migration defines column" do |body, matcher|
-          body.should match(/t\.#{type.to_s} :#{name.to_s}/)
-        end
+        simple_matcher("migration defines column") { |given| given =~ /t\.#{type.to_s} :#{name.to_s}/ }
       end
-      
     end
   end
 end