merb-slices 0.9.7 → 0.9.8

data/lib/generators/templates/full/spec/controllers/main_spec.rb

@@ -5,7 +5,7 @@ describe "<%= module_name %>::Main (controller)" do
   # Feel free to remove the specs below
   
   before :all do
-    Merb::Router.prepare { |r| r.add_slice(:<%= module_name %>) } if standalone?
+    Merb::Router.prepare { add_slice(:<%= module_name %>) } if standalone?
   end
   
   after :all do
@@ -35,15 +35,21 @@ describe "<%= module_name %>::Main (controller)" do
     controller.should be_kind_of(<%= module_name %>::Main)
     controller.action_name.should == 'index'
   end
-  
-  it "should have routes in <%= module_name %>.routes" do
-    <%= module_name %>.routes.should_not be_empty
-  end
-  
+    
   it "should have a slice_url helper method for slice-specific routes" do
     controller = dispatch_to(<%= module_name %>::Main, 'index')
-    controller.slice_url(:action => 'show', :format => 'html').should == "/<%= base_name %>/main/show.html"
-    controller.slice_url(:<%= symbol_name %>_index, :format => 'html').should == "/<%= base_name %>/index.html"
+    
+    url = controller.url(:<%= symbol_name %>_default, :controller => 'main', :action => 'show', :format => 'html')
+    url.should == "/<%= base_name %>/main/show.html"
+    controller.slice_url(:controller => 'main', :action => 'show', :format => 'html').should == url
+    
+    url = controller.url(:<%= symbol_name %>_index, :format => 'html')
+    url.should == "/<%= base_name %>/index.html"
+    controller.slice_url(:index, :format => 'html').should == url
+    
+    url = controller.url(:<%= symbol_name %>_home)
+    url.should == "/<%= base_name %>"
+    controller.slice_url(:home).should == url
   end
   
   it "should have helper methods for dealing with public paths" do
@@ -51,6 +57,10 @@ describe "<%= module_name %>::Main (controller)" do
     controller.public_path_for(:image).should == "/slices/<%= base_name %>/images"
     controller.public_path_for(:javascript).should == "/slices/<%= base_name %>/javascripts"
     controller.public_path_for(:stylesheet).should == "/slices/<%= base_name %>/stylesheets"
+    
+    controller.image_path.should == "/slices/<%= base_name %>/images"
+    controller.javascript_path.should == "/slices/<%= base_name %>/javascripts"
+    controller.stylesheet_path.should == "/slices/<%= base_name %>/stylesheets"
   end
   
   it "should have a slice-specific _template_root" do

data/lib/generators/templates/thin/README

@@ -75,19 +75,19 @@ file: config/router.rb
 
 # example: /<%= base_name %>/:controller/:action/:id
 
-r.add_slice(:<%= module_name %>)
+add_slice(:<%= module_name %>)
 
 # example: /foo/:controller/:action/:id
 
-r.add_slice(:<%= module_name %>, 'foo') # same as :path => 'foo'
+add_slice(:<%= module_name %>, 'foo') # same as :path => 'foo'
 
 # example: /:lang/:controller/:action/:id (with :a param set)
 
-r.add_slice(:<%= module_name %>, :path => ':lang', :params => { :a => 'b' })
+add_slice(:<%= module_name %>, :path => ':lang', :params => { :a => 'b' })
 
 # example: /:controller/:action/:id
 
-r.slice(:<%= module_name %>)
+slice(:<%= module_name %>)
 
 Normally you should also run the following rake task:
 

data/lib/generators/templates/very_thin/README

@@ -55,19 +55,19 @@ file: config/router.rb
 
 # example: /<%= base_name %>/:controller/:action/:id
 
-r.add_slice(:<%= module_name %>)
+add_slice(:<%= module_name %>)
 
 # example: /foo/:controller/:action/:id
 
-r.add_slice(:<%= module_name %>, 'foo') # same as :path => 'foo'
+add_slice(:<%= module_name %>, 'foo') # same as :path => 'foo'
 
 # example: /:lang/:controller/:action/:id (with :a param set)
 
-r.add_slice(:<%= module_name %>, :path => ':lang', :params => { :a => 'b' })
+add_slice(:<%= module_name %>, :path => ':lang', :params => { :a => 'b' })
 
 # example: /:controller/:action/:id
 
-r.slice(:<%= module_name %>)
+slice(:<%= module_name %>)
 
 Normally you should also run the following rake task:
 

data/lib/merb-slices.rb

@@ -39,8 +39,8 @@ if defined?(Merb::Plugins)
       # Remove a single file and the classes loaded by it from ObjectSpace.
       #
       # @param file<String> The file to load.
-      def remove_file(file)
-        Merb::BootLoader::LoadClasses.remove_file file
+      def remove_classes_in_file(file)
+        Merb::BootLoader::LoadClasses.remove_classes_in_file file
       end
         
       # Load classes from given paths - using path/glob pattern.
@@ -52,7 +52,7 @@ if defined?(Merb::Plugins)
     
       # Reload the router - takes all_slices into account to load slices at runtime.
       def reload_router!
-        Merb::BootLoader::LoadClasses.reload_router!
+        Merb::BootLoader::Router.reload!
       end
       
       # Slice-level paths for all loaded slices.

data/lib/merb-slices/controller_mixin.rb

@@ -34,7 +34,7 @@ module Merb
               self.send(:extend, Merb::Slices::ControllerMixin::MixinMethods)
             end
             # Reference this controller's slice module
-            self.class_inheritable_accessor :slice
+            self.class_inheritable_accessor :slice, :instance_writer => false
             self.slice = slice_mod
             # Setup template roots
             if options[:templates_for]
@@ -86,12 +86,39 @@ module Merb
           def slice; self.class.slice; end
           
           # Generate a url - takes the slice's :path_prefix into account.
-          def slice_url(name, rparams={})
-            self.slice.url(name, rparams, { 
-              :controller => controller_name,
-              :action => action_name,
-              :format => params[:format]
-            })
+          #
+          # @param *args<Array[Symbol,Hash]> 
+          #   There are several possibilities regarding arguments:
+          #   - when passing a Hash only, the :default route of the current 
+          #     slice will be used
+          #   - when a single Symbol is passed, it's used as the route name,
+          #     while the slice itself will be the current one
+          #   - when two Symbols are passed, the first will be the slice name,
+          #     the second will be the route name
+          #   - a Hash with additional params can optionally be passed
+          # 
+          # @return <String> A uri based on the requested slice.
+          #
+          # @example slice_url(:controller => 'foo', :action => 'bar')
+          # @example slice_url(:awesome, :format => 'html')
+          # @example slice_url(:forum, :posts, :format => 'xml')          
+          def slice_url(*args)
+            opts = args.last.is_a?(Hash) ? args.pop : {}
+            slice_name, route_name = if args[0].is_a?(Symbol) && args[1].is_a?(Symbol)
+              [args.shift, args.shift] # other slice identifier, route name
+            elsif args[0].is_a?(Symbol)
+              [slice.identifier_sym, args.shift] # self, route name
+            else
+              [slice.identifier_sym, :default] # self, default route
+            end
+            
+            routes = Merb::Slices.named_routes[slice_name]
+            unless routes && route = routes[route_name]
+              raise Merb::Router::GenerationError, "Named route not found: #{route_name}"
+            end
+            
+            args.push(opts)
+            route.generate(args, params)
           end
 
           private

data/lib/merb-slices/merbtasks.rb

@@ -1,4 +1,4 @@
-require "rubygems/dependency_installer"
+require "merb-core/tasks/merb_rake_helper"
 
 desc "Show information on application slices"
 task :slices => [ "slices:list" ]
@@ -22,42 +22,13 @@ namespace :slices do
   task :install_as_gem do
     if ENV['GEM']
       ENV['GEM_DIR'] ||= File.join(Merb.root, 'gems')
-      puts "Installing #{ENV["GEM"]} as a local gem"
-      install_gem(ENV['GEM_DIR'], ENV['GEM'], ENV['VERSION'])
+      options = { :install_dir => ENV['GEM_DIR'], 
+                  :cache => true, :ignore_dependencies => true }
+      options[:version] = ENV['VERSION'] if ENV['VERSION']
+      Merb::RakeHelper.install_package(ENV['GEM'], options)
     else
       puts "No slice GEM specified"
     end
   end
   
-  # Install a gem - looks remotely and locally; won't process rdoc or ri options.
-  def install_gem(install_dir, gem, version = nil)
-    Gem.configuration.update_sources = false
-    Gem.clear_paths # default to plain rubygems path
-    installer = Gem::DependencyInstaller.new(:install_dir => install_dir)
-    exception = nil
-    begin
-        installer.install gem, version
-      rescue Gem::InstallError => e
-        exception = e
-      rescue Gem::GemNotFoundException => e
-      puts "Locating #{gem} in local gem path cache..."
-      spec = if version
-        Gem.source_index.find_name(gem, "= #{version}").first
-      else
-        Gem.source_index.find_name(gem).sort_by { |g| g.version }.last
-      end
-      if spec && File.exists?(gem_file = 
-        File.join(spec.installation_path, 'cache', "#{spec.full_name}.gem"))
-        installer.install gem_file
-      end
-      exception = e
-    end
-    if installer.installed_gems.empty? && e
-      puts "Failed to install gem '#{gem}' (#{e.message})"
-    end
-    installer.installed_gems.each do |spec|
-      puts "Successfully installed #{spec.full_name}"
-    end
-  end
-  
 end

data/lib/merb-slices/module.rb

@@ -1,10 +1,10 @@
 module Merb
   module Slices
     
-    VERSION = "0.9.4"
+    VERSION = "0.9.8"
     
     class << self
-    
+      
       # Retrieve a slice module by name 
       #
       # @param <#to_s> The slice module to check for.
@@ -74,7 +74,7 @@ module Merb
       # @param slice_module<#to_s> The Slice module to unregister.
       def unregister(slice_module)
         if (slice = self[slice_module]) && self.paths.delete(module_name = slice.name)
-          slice.loadable_files.each { |file| Merb::Slices::Loader.remove_file file }
+          slice.loadable_files.each { |file| Merb::Slices::Loader.remove_classes_in_file file }
           Object.send(:remove_const, module_name)
           unless Object.const_defined?(module_name)
             Merb.logger.info!("Unregistered slice #{module_name}")
@@ -182,6 +182,12 @@ module Merb
         DynamicLoader.stop
       end
       
+      # @return <Hash[Hash]> 
+      #   A Hash mapping between slice identifiers and non-prefixed named routes.
+      def named_routes
+        @named_routes ||= {}
+      end
+      
       # @return <Hash>
       #   The configuration loaded from Merb.root / "config/slices.yml" or, if
       #   the load fails, an empty hash.

data/lib/merb-slices/module_mixin.rb

@@ -2,10 +2,12 @@ module Merb
   module Slices
     module ModuleMixin
       
+      # See bin/slice for this - used by ModuleMixin#push_app_path
+      $SLICE_MODULE ||= false
+      
       def self.extended(slice_module)
         slice_module.meta_class.module_eval do
           attr_accessor :identifier, :identifier_sym, :root, :file
-          attr_accessor :routes, :named_routes
           attr_accessor :description, :version, :author
         end
       end
@@ -33,7 +35,12 @@ module Merb
       
       # Check if there have been any routes setup.
       def routed?
-        self.routes && !self.routes.empty?
+        self.named_routes && !self.named_routes.empty?
+      end
+      
+      # Whether we're in an application or running from the slice dir itself.
+      def standalone?
+        Merb.root == self.root
       end
       
       # Return a value suitable for routes/urls.
@@ -58,6 +65,11 @@ module Merb
         Merb::Slices::config[self.identifier_sym] ||= {}
       end
       
+      # @return <Hash> The named routes for this slice.
+      def named_routes
+        Merb::Slices.named_routes[self.identifier_sym] ||= {}
+      end
+      
       # Load slice and it's classes located in the slice-level load paths.
       # 
       # Assigns collected_slice_paths and collected_app_paths, then loads
@@ -93,35 +105,6 @@ module Merb
       def collected_app_paths
         @collected_app_paths ||= []
       end
-      
-      # Generate a url - takes the slice's :path_prefix into account.
-      #
-      # This is only relevant for default routes, as named routes are
-      # handled correctly without any special considerations.
-      #
-      # @param name<#to_sym,Hash> The name of the URL to generate.
-      # @param rparams<Hash> Parameters for the route generation.
-      #
-      # @return String The generated URL.
-      #
-      # @notes If a hash is used as the first argument, a default route will be
-      #   generated based on it and rparams.
-      def url(name, rparams = {}, defaults = {})
-        defaults = rparams if name.is_a?(Hash) && defaults.empty?
-        rparams  = name    if name.is_a?(Hash)
-        
-        if name.is_a?(Symbol)
-          raise "Named route not found: #{name}" unless self.named_routes[name]
-          uri = Merb::Router.generate(name, rparams, defaults)
-        else
-          defaults[:controller] = defaults[:controller].gsub(%r|^#{self.identifier_sym}/|, '') if defaults[:controller]
-          uri = Merb::Router.generate(name, rparams, defaults)
-          uri = self[:path_prefix] / uri unless self[:path_prefix].blank?
-          uri = "/#{uri}" unless uri[0,1] == '/'
-        end
-        
-        Merb::Config[:path_prefix] ? Merb::Config[:path_prefix] + uri : uri
-      end
     
       # The slice-level load paths to use when loading the slice.
       #
@@ -239,8 +222,13 @@ module Merb
       # @param path<String> The full path
       # @param file_glob<String>
       #   A glob that will be used to autoload files under the path. Defaults to "**/*.rb".
+      #
+      # @note The :public path is adapted when the slice is run from bin/slice.
       def push_app_path(type, path, file_glob = "**/*.rb")
         enforce!(type => Symbol)
+        if type == :public && standalone? && $SLICE_MODULE
+          path.gsub!(/\/slices\/#{self.identifier}$/, '')
+        end
         app_paths[type] = [path, file_glob]
       end
     

data/lib/merb-slices/router_ext.rb

@@ -15,7 +15,7 @@ module Merb
       # @yield A new Behavior instance is yielded in the block for nested routes.
       # @yieldparam ns<Behavior> The namespace behavior object.
       #
-      # @example r.all_slices('BlogSlice' => 'blog', 'ForumSlice' => { :path => 'forum' })
+      # @example all_slices('BlogSlice' => 'blog', 'ForumSlice' => { :path => 'forum' })
       #
       # @note The block is yielded for each slice individually.
       def all_slices(config = {}, &block)
@@ -41,16 +41,19 @@ module Merb
         if Merb::Slices.exists?(slice_module)
           options = { :path => options } if options.is_a?(String)
           slice_module = Object.full_const_get(slice_module.to_s.camel_case) if slice_module.class.in?(String, Symbol)
-          namespace = options[:namespace] || slice_module.to_s.snake_case
-          options[:path] ||= slice_module[:path_prefix] || options[:namespace] || slice_module.identifier
+          namespace = options[:namespace] || slice_module.identifier_sym
+          options[:path] ||= options[:path_prefix] || slice_module[:path_prefix] || options[:namespace] || slice_module.identifier
           options[:default_routes] = true unless options.key?(:default_routes)
           options[:prepend_routes] = block if block_given?
           slice_module[:path_prefix] = options[:path]
           Merb.logger.info!("Mounting slice #{slice_module} at /#{options[:path]}")
           
+          # reset the inherited controller prefix - especially for 'slice' entries (see below)
+          @options[:controller_prefix] = nil if options.delete(:reset_controller_prefix)
+          
           # setup routes - capture the slice's routes for easy reference
-          slice_module.routes, slice_module.named_routes = Merb::Router.capture do
-            self.namespace(namespace.to_sym, options.except(:default_routes, :prepend_routes, :append_routes)) do |ns|
+          self.namespace(namespace, options.except(:default_routes, :prepend_routes, :append_routes, :path_prefix)) do |ns|
+            Merb::Slices.named_routes[slice_module.identifier_sym] = ns.capture do
               options[:prepend_routes].call(ns) if options[:prepend_routes].respond_to?(:call)
               slice_module.setup_router(ns)     # setup the routes from the slice itself
               options[:append_routes].call(ns)  if options[:append_routes].respond_to?(:call)
@@ -65,9 +68,9 @@ module Merb
       
       # Insert a slice directly into the current router context.
       #
-      # This will still setup a namespace, but doesn't set a path prefix. 
+      # This will still setup a namespace, but doesn't set a path prefix. Only for special cases.
       def slice(slice_module, options = {}, &block)
-        add_slice(slice_module, options.merge(:path => ''), &block)
+        add_slice(slice_module, options.merge(:path => '', :reset_controller_prefix => true), &block)
       end
       
     end

data/spec/full_slice_generator_spec.rb

@@ -1,14 +1,43 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
+slices_path = File.dirname(__FILE__) / 'slices'
+
 describe Merb::Generators::FullSliceGenerator do
   
   describe "templates" do
     
+    before(:all) { FileUtils.rm_rf(slices_path / 'testing') rescue nil }
+    after(:all)  { FileUtils.rm_rf(slices_path / 'testing') rescue nil }
+    
     before do
-      @generator = Merb::Generators::FullSliceGenerator.new('/tmp', {}, 'testing')
+      @generator = Merb::Generators::FullSliceGenerator.new(slices_path, {}, 'testing')
     end
     
-    it "should create a number of templates"
+    it "should create a number of templates" do
+      @generator.invoke!
+      files = Dir[slices_path / 'testing' / '**' / '*'].map do |path| 
+        path.relative_path_from(slices_path)
+      end
+      expected = [
+        "testing/app", "testing/app/controllers", "testing/app/controllers/application.rb", 
+        "testing/app/controllers/main.rb", "testing/app/helpers", 
+        "testing/app/helpers/application_helper.rb", "testing/app/views", 
+        "testing/app/views/layout", "testing/app/views/layout/testing.html.erb", 
+        "testing/app/views/main", "testing/app/views/main/index.html.erb", 
+        "testing/config", "testing/config/init.rb", "testing/lib", "testing/lib/testing", 
+        "testing/lib/testing/merbtasks.rb", "testing/lib/testing/slicetasks.rb", 
+        "testing/lib/testing/spectasks.rb", "testing/lib/testing.rb", 
+        "testing/LICENSE", "testing/public", "testing/public/javascripts", 
+        "testing/public/javascripts/master.js", "testing/public/stylesheets", 
+        "testing/public/stylesheets/master.css", "testing/Rakefile", 
+        "testing/README", "testing/spec", "testing/spec/controllers", 
+        "testing/spec/controllers/main_spec.rb", "testing/spec/spec_helper.rb", 
+        "testing/spec/testing_spec.rb", "testing/stubs", "testing/stubs/app", 
+        "testing/stubs/app/controllers", "testing/stubs/app/controllers/application.rb", 
+        "testing/stubs/app/controllers/main.rb", "testing/TODO"
+      ]
+      files.should == expected
+    end
     
     it "should render templates successfully" do
       lambda { @generator.render! }.should_not raise_error

data/spec/full_slice_spec.rb

@@ -0,0 +1,162 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+slices_path = File.dirname(__FILE__) / 'slices'
+
+describe "A slice" do
+    
+  before(:all) do
+    self.current_slice_root = slices_path / 'full-test-slice'
+    
+    # Uncomment this re-generate the slice - but remove the specs dir!
+    
+    # FileUtils.rm_rf(slices_path / 'full-test-slice') rescue nil
+    # generator = Merb::Generators::FullSliceGenerator.new(slices_path, {}, 'full-test-slice')
+    # generator.invoke!
+    
+    # Add the slice to the search path
+    Merb::Plugins.config[:merb_slices][:auto_register] = true
+    Merb::Plugins.config[:merb_slices][:search_path]   = slices_path
+
+    Merb.start(
+      :testing => true, 
+      :adapter => 'runner', 
+      :environment => ENV['MERB_ENV'] || 'test',
+      :merb_root => Merb.root
+    )
+  end
+  
+  # Uncomment this re-generate the slice
+  
+  # after(:all) do
+  #   FileUtils.rm_rf(slices_path / 'full-test-slice') rescue nil
+  # end
+  
+  before :all do
+    Merb::Router.prepare { add_slice(:FullTestSlice) }
+  end
+  
+  it "should be registered in Merb::Slices.slices" do
+    Merb::Slices.slices.should include(FullTestSlice)
+  end
+  
+  it "should be registered in Merb::Slices.paths" do
+    Merb::Slices.paths[FullTestSlice.name].should == current_slice_root
+  end
+  
+  it "should have an :identifier property" do
+    FullTestSlice.identifier.should == "full-test-slice"
+  end
+  
+  it "should have an :identifier_sym property" do
+    FullTestSlice.identifier_sym.should == :full_test_slice
+  end
+  
+  it "should have a :root property" do
+    FullTestSlice.root.should == Merb::Slices.paths[FullTestSlice.name]
+    FullTestSlice.root_path('app').should == current_slice_root / 'app'
+  end
+  
+  it "should have a :file property" do
+    FullTestSlice.file.should == current_slice_root / 'lib' / 'full-test-slice.rb'
+  end
+  
+  it "should have metadata properties" do
+    FullTestSlice.description.should == "FullTestSlice is a chunky Merb slice!"
+    FullTestSlice.version.should == "0.0.1"
+    FullTestSlice.author.should == "YOUR NAME"
+  end
+  
+  it "should have a :named_routes property" do
+    FullTestSlice.named_routes[:default].should be_kind_of(Merb::Router::Route)
+    FullTestSlice.named_routes[:index].should be_kind_of(Merb::Router::Route)
+  end
+  
+  it "should have a config property (Hash)" do
+    FullTestSlice.config.should be_kind_of(Hash)
+  end
+  
+  it "should have bracket accessors as shortcuts to the config" do
+    FullTestSlice[:foo] = 'bar'
+    FullTestSlice[:foo].should == 'bar'
+    FullTestSlice[:foo].should == FullTestSlice.config[:foo]
+  end
+  
+  it "should have a :layout config option set" do
+    FullTestSlice.config[:layout].should == :full_test_slice
+  end
+  
+  it "should have a dir_for method" do
+    app_path = FullTestSlice.dir_for(:application)
+    app_path.should == current_slice_root / 'app'
+    [:view, :model, :controller, :helper, :mailer, :part].each do |type|
+      FullTestSlice.dir_for(type).should == app_path / "#{type}s"
+    end
+    public_path = FullTestSlice.dir_for(:public)
+    public_path.should == current_slice_root / 'public'
+    [:stylesheet, :javascript, :image].each do |type|
+      FullTestSlice.dir_for(type).should == public_path / "#{type}s"
+    end
+  end
+  
+  it "should have a app_dir_for method" do
+    root_path = FullTestSlice.app_dir_for(:root)
+    root_path.should == Merb.root / 'slices' / 'full-test-slice'
+    app_path = FullTestSlice.app_dir_for(:application)
+    app_path.should == root_path / 'app'
+    [:view, :model, :controller, :helper, :mailer, :part].each do |type|
+      FullTestSlice.app_dir_for(type).should == app_path / "#{type}s"
+    end
+    public_path = FullTestSlice.app_dir_for(:public)
+    public_path.should == Merb.dir_for(:public) / 'slices' / 'full-test-slice'
+    [:stylesheet, :javascript, :image].each do |type|
+      FullTestSlice.app_dir_for(type).should == public_path / "#{type}s"
+    end
+  end
+  
+  it "should have a public_dir_for method" do
+    public_path = FullTestSlice.public_dir_for(:public)
+    public_path.should == '/slices' / 'full-test-slice'
+    [:stylesheet, :javascript, :image].each do |type|
+      FullTestSlice.public_dir_for(type).should == public_path / "#{type}s"
+    end
+  end
+  
+  it "should have a public_path_for method" do
+    public_path = FullTestSlice.public_dir_for(:public)
+    FullTestSlice.public_path_for("path", "to", "file").should == public_path / "path" / "to" / "file"
+    [:stylesheet, :javascript, :image].each do |type|
+      FullTestSlice.public_path_for(type, "path", "to", "file").should == public_path / "#{type}s" / "path" / "to" / "file"
+    end
+  end
+  
+  it "should have a app_path_for method" do
+    FullTestSlice.app_path_for("path", "to", "file").should == FullTestSlice.app_dir_for(:root) / "path" / "to" / "file"
+    FullTestSlice.app_path_for(:controller, "path", "to", "file").should == FullTestSlice.app_dir_for(:controller) / "path" / "to" / "file"
+  end
+  
+  it "should have a slice_path_for method" do
+    FullTestSlice.slice_path_for("path", "to", "file").should == FullTestSlice.dir_for(:root) / "path" / "to" / "file"
+    FullTestSlice.slice_path_for(:controller, "path", "to", "file").should == FullTestSlice.dir_for(:controller) / "path" / "to" / "file"
+  end
+  
+  it "should keep a list of path component types to use when copying files" do
+    (FullTestSlice.mirrored_components & FullTestSlice.slice_paths.keys).length.should == FullTestSlice.mirrored_components.length
+  end
+  
+  it "should have a slice_url helper method for slice-specific routes" do
+    controller = dispatch_to(FullTestSlice::Main, 'index')
+    
+    url = controller.url(:full_test_slice_default, :controller => 'main', :action => 'show', :format => 'html')
+    url.should == "/full-test-slice/main/show.html"
+    controller.slice_url(:controller => 'main', :action => 'show', :format => 'html').should == url
+    
+    url = controller.url(:full_test_slice_index, :format => 'html')
+    url.should == "/full-test-slice/index.html"
+    controller.slice_url(:index, :format => 'html').should == url
+    
+    url = controller.url(:full_test_slice_home)
+    url.should == "/full-test-slice/"
+    controller.slice_url(:home).should == url
+  end
+    
+end