merb 0.4.2 → 0.5.0

data/lib/merb/mixins/responder.rb

@@ -370,7 +370,7 @@ module Merb
     module Rest
       
       TYPES = {}
-      RESPONSE_HEADERS = {}
+      RESPONSE_HEADERS = Hash.new([])
       TRANSFORM_METHODS = {}
       TRANSFORM_METHOD_DEFAULTS = {}
 

data/lib/merb/mixins/view_context.rb

@@ -2,6 +2,9 @@ module Merb
   # The ViewContextMixin module provides a number of helper methods to views for
   # linking to assets and other pages, dealing with JavaScript, and caching.
   module ViewContextMixin
+    
+    include Merb::Assets::AssetHelpers
+    
     # :section: Accessing Assets
     # Merb provides views with convenience methods for links images and other assets.
     
@@ -52,8 +55,8 @@ module Merb
         if img =~ %r{^https?://}
           ''
         else
-          if Merb::Server.config[:path_prefix]
-            Merb::Server.config[:path_prefix] + '/images/'
+          if Merb::Config[:path_prefix]
+            Merb::Config[:path_prefix] + '/images/'
           else
             '/images/'
           end
@@ -162,6 +165,77 @@ module Merb
     #
     # See each method's documentation for more information.
     
+    # :section: Bundling Asset Files
+    # 
+    # The key to making a fast web application is to reduce both the amount of
+    # data transfered and the number of client-server interactions. While having
+    # many small, module Javascript or stylesheet files aids in the development
+    # process, your web application will benefit from bundling those assets in
+    # the production environment.
+    # 
+    # An asset bundle is a set of asset files which are combined into a single
+    # file. This reduces the number of requests required to render a page, and
+    # can reduce the amount of data transfer required if you're using gzip
+    # encoding.
+    # 
+    # Asset bundling is always enabled in production mode, and can be optionally
+    # enabled in all environments by setting the <tt>:bundle_assets</tt> value
+    # in <tt>config/merb.yml</tt> to +true+.
+    # 
+    # ==== Examples
+    # 
+    # In the development environment, this:
+    # 
+    #   js_include_tag :prototype, :lowpro, :bundle => true
+    # 
+    # will produce two <script> elements. In the production mode, however, the
+    # two files will be concatenated in the order given into a single file,
+    # <tt>all.js</tt>, in the <tt>public/javascripts</tt> directory.
+    # 
+    # To specify a different bundle name:
+    # 
+    #   css_include_tag :typography, :whitespace, :bundle => :base
+    #   css_include_tag :header, :footer, :bundle => "content"
+    #   css_include_tag :lightbox, :images, :bundle => "lb.css"
+    # 
+    # (<tt>base.css</tt>, <tt>content.css</tt>, and <tt>lb.css</tt> will all be
+    # created in the <tt>public/stylesheets</tt> directory.)
+    # 
+    # == Callbacks
+    # 
+    # To use a Javascript or CSS compressor, like JSMin or YUI Compressor:
+    # 
+    #   Merb::Assets::JavascriptAssetBundler.add_callback do |filename|
+    #     system("/usr/local/bin/yui-compress #{filename}")
+    #   end
+    #   
+    #   Merb::Assets::StylesheetAssetBundler.add_callback do |filename|
+    #     system("/usr/local/bin/css-min #{filename}")
+    #   end
+    # 
+    # These blocks will be run after a bundle is created.
+    # 
+    # == Bundling Required Assets
+    # 
+    # Combining the +require_css+ and +require_js+ helpers with bundling can be
+    # problematic. You may want to separate out the common assets for your
+    # application -- Javascript frameworks, common CSS, etc. -- and bundle those
+    # in a "base" bundle. Then, for each section of your site, bundle the
+    # required assets into a section-specific bundle.
+    # 
+    # <b>N.B.: If you bundle an inconsistent set of assets with the same name,
+    # you will have inconsistent results. Be thorough and test often.</b>
+    # 
+    # ==== Example
+    # 
+    # In your application layout:
+    # 
+    #   js_include_tag :prototype, :lowpro, :bundle => :base
+    # 
+    # In your controller layout:
+    # 
+    #   require_js :bundle => :posts
+    
     # The require_js method can be used to require any JavaScript
     # file anywhere in your templates. Regardless of how many times
     # a single script is included with require_js, Merb will only include
@@ -182,7 +256,7 @@ module Merb
       @required_js |= js
     end
     
-    # The require_ccs method can be used to require any CSS
+    # The require_css method can be used to require any CSS
     # file anywhere in your templates. Regardless of how many times
     # a single stylesheet is included with require_css, Merb will only include
     # it once in the header.
@@ -204,7 +278,13 @@ module Merb
     
     # A method used in the layout of an application to create +<script>+ tags to include JavaScripts required in 
     # in templates and subtemplates using require_js.
-    #
+    # 
+    # ==== Options
+    # bundle::  The name of the bundle the scripts should be combined into.
+    #           If +nil+ or +false+, the bundle is not created. If +true+, a
+    #           bundle named <tt>all.js</tt> is created. Otherwise,
+    #           <tt>:bundle</tt> is treated as an asset name.
+    # 
     # ==== Examples
     #   # my_action.herb has a call to require_js 'jquery'
     #   # File: layout/application.html.erb
@@ -218,14 +298,20 @@ module Merb
     #   #    <script src="/javascripts/effects.js" type="text/javascript"></script>
     #   #    <script src="/javascripts/validation.js" type="text/javascript"></script>
     #
-    def include_required_js
+    def include_required_js(options = {})
       return '' if @required_js.nil?
-      js_include_tag(*@required_js)
+      js_include_tag(*(@required_js + [options]))
     end
     
     # A method used in the layout of an application to create +<link>+ tags for CSS stylesheets required in 
     # in templates and subtemplates using require_css.
-    #
+    # 
+    # ==== Options
+    # bundle::  The name of the bundle the stylesheets should be combined into.
+    #           If +nil+ or +false+, the bundle is not created. If +true+, a
+    #           bundle named <tt>all.css</tt> is created. Otherwise,
+    #           <tt>:bundle</tt> is treated as an asset name.
+    # 
     # ==== Examples
     #   # my_action.herb has a call to require_css 'style'
     #   # File: layout/application.html.erb
@@ -238,15 +324,21 @@ module Merb
     #   # => <link href="/stylesheets/style.css" media="all" rel="Stylesheet" type="text/css"/>
     #   #    <link href="/stylesheets/ie-specific.css" media="all" rel="Stylesheet" type="text/css"/>
     #
-    def include_required_css
+    def include_required_css(options = {})
       return '' if @required_css.nil?
-      css_include_tag(*@required_css)
+      css_include_tag(*(@required_css + [options]))
     end
     
     # The js_include_tag method will create a JavaScript 
     # +<include>+ tag for each script named in the arguments, appending
     # '.js' if it is left out of the call.
-    #
+    # 
+    # ==== Options
+    # bundle::  The name of the bundle the scripts should be combined into.
+    #           If +nil+ or +false+, the bundle is not created. If +true+, a
+    #           bundle named <tt>all.js</tt> is created. Otherwise,
+    #           <tt>:bundle</tt> is treated as an asset name.
+    # 
     # ==== Examples
     #   js_include_tag 'jquery'
     #   # => <script src="/javascripts/jquery.js" type="text/javascript"></script>
@@ -263,46 +355,80 @@ module Merb
     #   #    <script src="/javascripts/validation.js" type="text/javascript"></script>
     #
     def js_include_tag(*scripts)
+      options = scripts.last.is_a?(Hash) ? scripts.pop : {}
       return nil if scripts.empty?
-      include_tag = ""
-      scripts.each do |script|
-        script = script.to_s
-        url = "/javascripts/#{script =~ /\.js$/ ? script : script + '.js'}"
-        url = Merb::Server.config[:path_prefix] + url if Merb::Server.config[:path_prefix]
-        include_tag << %Q|<script src="#{url}" type="text/javascript">//</script>\n|
+      
+      if (bundle_name = options[:bundle]) && Merb::Assets.bundle? && scripts.size > 1
+        bundler = Merb::Assets::JavascriptAssetBundler.new(bundle_name, *scripts)
+        bundled_asset = bundler.bundle!
+        return js_include_tag(bundled_asset)
+      end
+
+      tags = ""
+
+      for script in scripts
+        attrs = {
+          :src => asset_path(:javascript, script),
+          :type => "text/javascript"
+        }
+        tags << %Q{<script #{attrs.to_xml_attributes}>//</script>}
       end
-      include_tag
+
+      return tags
     end
     
     # The css_include_tag method will create a CSS stylesheet 
     # +<link>+ tag for each stylesheet named in the arguments, appending
     # '.css' if it is left out of the call.
+    # 
+    # ==== Options
+    # bundle::  The name of the bundle the stylesheets should be combined into.
+    #           If +nil+ or +false+, the bundle is not created. If +true+, a
+    #           bundle named <tt>all.css</tt> is created. Otherwise,
+    #           <tt>:bundle</tt> is treated as an asset name.
+    # media::   The media attribute for the generated link element. Defaults
+    #           to <tt>:all</tt>.
     #
     # ==== Examples
     #   css_include_tag 'style'
-    #   # => <link href="/stylesheets/style.css" media="all" rel="Stylesheet" type="text/css"/>
+    #   # => <link href="/stylesheets/style.css" media="all" rel="Stylesheet" type="text/css" />
     #
     #   css_include_tag 'style.css', 'layout'
-    #   # => <link href="/stylesheets/style.css" media="all" rel="Stylesheet" type="text/css"/>
-    #   #    <link href="/stylesheets/layout.css" media="all" rel="Stylesheet" type="text/css"/>
+    #   # => <link href="/stylesheets/style.css" media="all" rel="Stylesheet" type="text/css" />
+    #   #    <link href="/stylesheets/layout.css" media="all" rel="Stylesheet" type="text/css" />
     #
     #   css_include_tag :menu
-    #   # => <link href="/stylesheets/menu.css" media="all" rel="Stylesheet" type="text/css"/>
+    #   # => <link href="/stylesheets/menu.css" media="all" rel="Stylesheet" type="text/css" />
     #
     #   css_include_tag :style, :screen
-    #   # => <link href="/stylesheets/style.css" media="all" rel="Stylesheet" type="text/css"/>
-    #   #    <link href="/stylesheets/screen.css" media="all" rel="Stylesheet" type="text/css"/>
-    #
-    def css_include_tag(*scripts)
-      return nil if scripts.empty?
-      include_tag = ""
-      scripts.each do |script|
-        script = script.to_s
-        url = "/stylesheets/#{script =~ /\.css$/ ? script : script + '.css'}"
-        url = Merb::Server.config[:path_prefix] + url if Merb::Server.config[:path_prefix]
-        include_tag << %Q|<link href="#{url}" media="all" rel="Stylesheet" type="text/css"/>\n|
+    #   # => <link href="/stylesheets/style.css" media="all" rel="Stylesheet" type="text/css" />
+    #   #    <link href="/stylesheets/screen.css" media="all" rel="Stylesheet" type="text/css" />
+    # 
+    #  css_include_tag :style, :media => :print
+    #  # => <link href="/stylesheets/style.css" media="print" rel="Stylesheet" type="text/css" />
+    def css_include_tag(*stylesheets)
+      options = stylesheets.last.is_a?(Hash) ? stylesheets.pop : {}
+      return nil if stylesheets.empty?
+      
+      if (bundle_name = options[:bundle]) && Merb::Assets.bundle? && stylesheets.size > 1
+        bundler = Merb::Assets::StylesheetAssetBundler.new(bundle_name, *stylesheets)
+        bundled_asset = bundler.bundle!
+        return css_include_tag(bundled_asset)
       end
-      include_tag
+
+      tags = ""
+
+      for stylesheet in stylesheets
+        attrs = {
+          :href => asset_path(:stylesheet, stylesheet),
+          :type => "text/css",
+          :rel => "Stylesheet",
+          :media => options[:media] || :all
+        }
+        tags << %Q{<link #{attrs.to_xml_attributes} />}
+      end
+
+      return tags
     end
     
     # :section: Caching

data/lib/merb/mongrel_handler.rb

@@ -49,14 +49,14 @@ class MerbHandler < Mongrel::HttpHandler
     start      = Time.now
     benchmarks = {}
     
-    MERB_LOGGER.info("\nRequest: REQUEST_URI: #{
+    Merb.logger.info("\nRequest: REQUEST_URI: #{
       request.params[Mongrel::Const::REQUEST_URI]}  (#{Time.now.strftime("%Y-%m-%d %H:%M:%S")})")
     
     # Truncate the request URI if there's a path prefix so that an app can be
     # hosted inside a subdirectory, for example.
     if @@path_prefix
       if request.params[Mongrel::Const::PATH_INFO] =~ @@path_prefix
-        MERB_LOGGER.info("Path prefix #{@@path_prefix.inspect} removed from PATH_INFO and REQUEST_URI.")
+        Merb.logger.info("Path prefix #{@@path_prefix.inspect} removed from PATH_INFO and REQUEST_URI.")
         request.params[Mongrel::Const::PATH_INFO].sub!(@@path_prefix, '')
         request.params[Mongrel::Const::REQUEST_URI].sub!(@@path_prefix, '')
         path_info = request.params[Mongrel::Const::PATH_INFO]
@@ -75,11 +75,11 @@ class MerbHandler < Mongrel::HttpHandler
 
     if get_or_head && @files.can_serve(path_info)
       # File exists as-is so serve it up
-      MERB_LOGGER.info("Serving static file: #{path_info}")
+      Merb.logger.info("Serving static file: #{path_info}")
       @files.process(request,response)
     elsif get_or_head && @files.can_serve(page_cached)
       # Possible cached page, serve it up
-      MERB_LOGGER.info("Serving static file: #{page_cached}")
+      Merb.logger.info("Serving static file: #{page_cached}")
       request.params[Mongrel::Const::PATH_INFO] = page_cached
       @files.process(request,response)
     else
@@ -89,7 +89,7 @@ class MerbHandler < Mongrel::HttpHandler
       benchmarks[:controller] = controller.class.to_s
       benchmarks[:action]     = action
 
-      MERB_LOGGER.info("Routing to controller: #{controller.class} action: #{action}\nRoute Recognition & Parsing HTTP Input took: #{benchmarks[:setup_time]} seconds")
+      Merb.logger.info("Routing to controller: #{controller.class} action: #{action}\nRoute Recognition & Parsing HTTP Input took: #{benchmarks[:setup_time]} seconds")
       
       sendfile, clength = nil
       response.status   = controller.status
@@ -111,7 +111,7 @@ class MerbHandler < Mongrel::HttpHandler
         if @mongrel_x_sendfile
           # we want to emulate X-Sendfile header internally in mongrel
           benchmarks[:sendfile_time] = Time.now - start        
-          MERB_LOGGER.info("X-SENDFILE: #{sendfile}\nComplete Request took: #{
+          Merb.logger.info("X-SENDFILE: #{sendfile}\nComplete Request took: #{
             benchmarks[:sendfile_time]} seconds")
           file_status     = File.stat(sendfile)
           response.status = 200
@@ -152,7 +152,7 @@ class MerbHandler < Mongrel::HttpHandler
       total_request_time = Time.now - start
       benchmarks[:total_request_time] = total_request_time
         
-      MERB_LOGGER.info("Request Times: #{benchmarks.inspect}\nResponse status: #{response.status}\nComplete Request took: #{total_request_time} seconds, #{1.0/total_request_time} Requests/Second\n\n")
+      Merb.logger.info("Request Times: #{benchmarks.inspect}\nResponse status: #{response.status}\nComplete Request took: #{total_request_time} seconds, #{1.0/total_request_time} Requests/Second\n\n")
     end
   rescue Object => e
     # if an exception is raised here then something is 
@@ -161,8 +161,8 @@ class MerbHandler < Mongrel::HttpHandler
     response.send_status(500)
     response.send_header
     response.write("500 Internal Server Error")
-    MERB_LOGGER.error(Merb.exception(e))
+    Merb.logger.error(Merb.exception(e))
   ensure
-    MERB_LOGGER.flush
+    Merb.logger.flush
   end
 end

data/lib/merb/plugins.rb

@@ -1,7 +1,7 @@
 module Merb
   module Plugins
     def self.config
-      @config ||= File.exists?(MERB_ROOT / "config" / "plugins.yml") ? YAML.load(File.read(MERB_ROOT / "config" / "plugins.yml")) || {} : {}
+      @config ||= File.exists?(Merb.root / "config" / "plugins.yml") ? YAML.load(File.read(Merb.root / "config" / "plugins.yml")) || {} : {}
     end
     
     @rakefiles = []

data/lib/merb/request.rb

@@ -328,6 +328,30 @@ module Merb
     end
     
     class << self
+      # Escapes +s+ for use in a URL.
+      #
+      # ==== Parameter
+      #
+      # +s+ - String to URL escape.
+      #
+      def escape(s)
+        s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
+          '%'+$1.unpack('H2'*$1.size).join('%').upcase
+        }.tr(' ', '+')
+      end
+
+      # Unescapes a string (i.e., reverse URL escaping).
+      #
+      # ==== Parameter 
+      #
+      # +s+ - String to unescape.
+      #
+      def unescape(s)
+        s.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n){
+          [$1.delete('%')].pack('H*')
+        }
+      end
+      
       # parses a query string or the payload of a POST
       # request into the params hash. So for example:
       # /foo?bar=nik&post[title]=heya&post[body]=whatever
@@ -335,7 +359,7 @@ module Merb
       # {:bar => 'nik', :post => {:title => 'heya', :body => 'whatever'}}
       def query_parse(qs, d = '&;')
         (qs||'').split(/[#{d}] */n).inject({}) { |h,p| 
-          normalize_params(h, *Mongrel::HttpRequest.unescape(p).split('=',2))
+          normalize_params(h, *unescape(p).split('=',2))
         }.to_mash
       end
     

data/lib/merb/router.rb

@@ -1,31 +1,30 @@
 module Merb
-
   class Router
     SEGMENT_REGEXP = /(:([a-z_][a-z0-9_]*|:))/
     SEGMENT_REGEXP_WITH_BRACKETS = /(:[a-z_]+)(\[(\d+)\])?/
     JUST_BRACKETS = /\[(\d+)\]/
     PARENTHETICAL_SEGMENT_STRING = "([^\/.,;?]+)".freeze
-
+    
     @@named_routes = {}
     @@routes = []
     cattr_accessor :routes, :named_routes
-
+    
     class << self
       def append(&block)
         prepare(@@routes, [], &block)
       end
-
+      
       def prepend(&block)
         prepare([], @@routes, &block)
       end
-
+      
       def prepare(first = [], last = [], &block)
         @@routes = []
-        yield Behavior.new({}, {:action => 'index'}) # defaults
+        yield Behavior.new({}, { :action => 'index' }) # defaults
         @@routes = first + @@routes + last
         compile
       end
-
+      
       def compiled_statement
         @@compiled_statement = "lambda { |request, params|\n"
         @@compiled_statement << "  cached_path = request.path\n  cached_method = request.method.to_s\n  "
@@ -35,31 +34,37 @@ module Merb
         @@compiled_statement << "  end\n"
         @@compiled_statement << "}"
       end
-
+      
       def compile
         meta_def(:match, &eval(compiled_statement))
       end
-
+      
       def generate(name, params = {}, fallback = {})
-        raise "Named route not found: #{name}" unless @@named_routes.has_key? name
-        @@named_routes[name].generate(params, fallback).sub(/\/$/, '').squeeze("/")
+        name = name.to_sym
+        unless @@named_routes.key? name
+          raise "Named route not found: #{name}"
+        else
+          @@named_routes[name].generate(params, fallback)
+        end
       end
     end # self
-
+    
     # Cache procs for future reference in eval statement
     class CachedProc
       @@index = 0
       @@list = []
-
+      
       attr_accessor :cache, :index
-
+      
       def initialize(cache)
         @cache, @index = cache, CachedProc.register(self)
       end
-
+      
       # Make each CachedProc object embeddable within a string
-      def to_s() "CachedProc[#{@index}].cache" end
-
+      def to_s
+        "CachedProc[#{@index}].cache"
+      end
+      
       class << self
         def register(cached_code)
           CachedProc[@@index] = cached_code
@@ -70,11 +75,11 @@ module Merb
         def [](index) @@list[index] end
       end
     end # CachedProc
-
+    
     class Route
       attr_reader :conditions, :conditional_block
       attr_reader :params, :behavior, :segments, :index, :symbol
-
+      
       def initialize(conditions, params, behavior = nil, &conditional_block)
         @conditions, @params, @behavior = conditions, params, behavior
         @conditional_block = conditional_block
@@ -82,31 +87,25 @@ module Merb
           @segments = segments_from_path(path)
         end
       end
-
+      
       def to_s
-        r = ""
-        segments.each {|s|
-          if s.is_a?(Symbol)
-            r << ":#{s}"
-          else
-            r << s
-          end
-        }
-        r
+        segments.inject('') do |str,seg|
+          str << (seg.is_a?(Symbol) ? ":#{seg}" : seg)
+        end
       end
-
+      
       # Registers itself in the Router.routes array
       def register
         @index = Router.routes.size
         Router.routes << self
         self
       end
-
+      
       # Get the symbols out of the segments array
       def symbol_segments
         segments.select{ |s| s.is_a?(Symbol) }
       end
-
+      
       # Turn a path into string and symbol segments so it can be reconstructed, as in the
       # case of a named route.
       def segments_from_path(path)
@@ -121,17 +120,17 @@ module Merb
         segments << strip[path] unless path.empty?
         segments
       end
-
+      
       # Name this route
       def name(symbol = nil)
-        @symbol = symbol
+        raise ArgumentError unless (@symbol = symbol).is_a?(Symbol)
         Router.named_routes[@symbol] = self
       end
-
+      
       def regexp?
-        behavior.regexp? || behavior.send(:ancestors).any?{ |a| a.regexp? }
+        behavior.regexp? || behavior.send(:ancestors).any? { |a| a.regexp? }
       end
-
+      
       # Given a hash of +params+, returns a string using the stored route segments
       # for reconstruction of the URL.
       def generate(params = {}, fallback = {})
@@ -141,7 +140,9 @@ module Merb
               if params.is_a? Hash
                 params[segment] || fallback[segment]
               else
-                if params.respond_to?(segment)
+                if segment == :id && params.respond_to?(:to_param) 
+                  params.to_param
+                elsif params.respond_to?(segment)
                   params.send(segment)
                 else
                   fallback[segment]
@@ -155,7 +156,7 @@ module Merb
           (value.respond_to?(:to_param) ? value.to_param : value).to_s
         end.join
       end
-
+      
       def if_conditions(params_as_string)
         cond = []
         condition_string = proc do |key, value, regexp_string|
@@ -169,7 +170,7 @@ module Merb
           "    (#{value.inspect} =~ #{regexp_string}" + captures + ")"
         end
         @conditions.each_pair do |key, value|
-
+          
           # Note: =~ is slightly faster than .match
           cond << case key
           when :path then condition_string[key, value, "cached_path"]
@@ -184,10 +185,10 @@ module Merb
         end
         cond
       end
-
+      
       def compile(first = false)
         code = ""
-        default_params = {:action => "index"}
+        default_params = { :action => "index" }
         get_value = proc do |key|
           if default_params.has_key?(key) && params[key][0] != ?"
             "#{params[key]} || \"#{default_params[key]}\""
@@ -195,7 +196,7 @@ module Merb
             "#{params[key]}"
           end
         end
-        params_as_string = params.keys.map{|k| "#{k.inspect} => #{get_value[k]}"}.join(", ")
+        params_as_string = params.keys.map { |k| "#{k.inspect} => #{get_value[k]}" }.join(', ')
         code << "  els" unless first
         code << "if  # #{@behavior.merged_original_conditions.inspect}\n  "
         code << if_conditions(params_as_string).join(" &&\n  ") << "\n"
@@ -206,7 +207,7 @@ module Merb
           code << "    [#{@index.inspect}, {#{params_as_string}}]\n"
         end
       end
-
+      
       def behavior_trace
         if @behavior
           puts @behavior.send(:ancestors).reverse.map{|a| a.inspect}.join("\n"); puts @behavior.inspect; puts
@@ -215,30 +216,65 @@ module Merb
         end
       end
     end # Route
-
-    # The Behavior class is an interim route-building class that ties pattern-matching +conditions+ to
-    # output parameters, +params+.
+    
+    # The Behavior class is an interim route-building class that ties 
+    # pattern-matching +conditions+ to output parameters, +params+.
     class Behavior
       attr_reader :placeholders, :conditions, :params
       attr_accessor :parent
-
+      
+      class << self
+        # Count the number of open parentheses in +string+, up to and including +pos+
+        def count_parens_up_to(string, pos)
+          string[0..pos].gsub(/[^\(]/, '').size
+        end
+        
+        # Concatenate strings and remove regexp end caps
+        def concat_without_endcaps(string1, string2)
+          return nil if !string1 and !string2
+          return string1 if string2.nil?
+          return string2 if string1.nil?
+          s1 = string1[-1] == ?$ ? string1[0..-2] : string1
+          s2 = string2[0] == ?^ ? string2[1..-1] : string2
+          s1 + s2
+        end
+        
+        # Join an array's elements into a string using " + " as a joiner, and
+        # surround string elements in quotes.
+        def array_to_code(arr)
+          code = ''
+          arr.each_with_index do |part, i|
+            code << ' + ' if i > 0
+            case part
+            when Symbol
+              code << part.to_s
+            when String
+              code << %{"#{part}"}
+            else
+              raise "Don't know how to compile array part: #{part.class} [#{i}]"
+            end
+          end
+          code
+        end
+      end # class << self
+      
       def initialize(conditions = {}, params = {}, parent = nil)
+        # Must wait until after deducing placeholders to set @params !
         @conditions, @params, @parent = conditions, {}, parent
         @placeholders = {}
         stringify_conditions
         copy_original_conditions
         deduce_placeholders
-        # Must wait until after deducing placeholders to set @params
-        @params.merge!(params)
+        @params.merge! params
       end
-
+      
       def add(path, params = {})
         match(path).to(params)
       end
-
+      
       # Matches a +path+ and any number of optional request methods as conditions of a route.
       # Alternatively, +path+ can be a hash of conditions, in which case +conditions+ is ignored.
-      # Yields 'self' so that sub-matching may occur.
+      # Yields a new instance so that sub-matching may occur.
       def match(path = '', conditions = {}, &block)
         if path.is_a? Hash
           conditions = path
@@ -247,28 +283,32 @@ module Merb
         end
         match_without_path(conditions, &block)
       end
-
+      
       def match_without_path(conditions = {})
         new_behavior = self.class.new(conditions, {}, self)
         conditions.delete :path if ['', '^$'].include?(conditions[:path])
         yield new_behavior if block_given?
         new_behavior
       end
-
+      
       def to_route(params = {}, &conditional_block)
-        @params.merge!(params)
-        Route.new(compiled_conditions, compiled_params, self, &conditional_block)
+        @params.merge! params
+        Route.new compiled_conditions, compiled_params, self, &conditional_block
       end
-
+      
       # Creates a Route from one or more Behavior objects, unless a +block+ is passed in.
       # If a block is passed in, a Behavior object is yielded and further .to operations
       # may be called in the block.  For example:
+      # 
       #   r.match('/:controller/:id).to(:action => 'show')
+      # 
       # vs.
-      #   r.to(:controller => "simple") do |simple|
-      #     simple.match('/test').to(:action => 'index')
-      #     simple.match('/other').to(:action => 'other')
+      #   
+      #   r.to :controller => 'simple' do |s|
+      #     s.match('/test').to(:action => 'index')
+      #     s.match('/other').to(:action => 'other')
       #   end
+      # 
       def to(params = {}, &block)
         if block_given?
           new_behavior = self.class.new({}, params, self)
@@ -278,129 +318,148 @@ module Merb
           to_route(params).register
         end
       end
-
-      # Takes a block and stores it for defered conditional routes.  The block takes the
-      # +request+ object and the +params+ hash as parameters and should return a hash of params.
-      # For example:
+      
+      # Takes a block and stores it for defered conditional routes. 
+      # The block takes the +request+ object and the +params+ hash as parameters 
+      # and should return a hash of params.
+      # 
       #   r.defer_to do |request, params|
-      #     params.merge(:controller => 'here', :action => 'there') if External.says_so?
+      #     params.merge :controller => 'here', :action => 'there'
       #   end
+      # 
       def defer_to(params = {}, &conditional_block)
         Router.routes << (route = to_route(params, &conditional_block))
         route
       end
-
+      
       def default_routes(params = {}, &block)
-        match(%r[/:controller(/:action(/:id)?)?(\.:format)?]).to(params, &block)
+        match(%r{/:controller(/:action(/:id)?)?(\.:format)?}).to(params, &block)
       end
-
-      def to_resources(params = {}, &block)
-        many_behaviors_to(resources_behaviors, params, &block)
+      
+      def namespace(name_or_path, &block)
+        yield self.class.new(:namespace => name_or_path.to_s)
       end
-
+      
       def resources(name, options = {})
-        # singular = name.singularize
-        next_level = match("/#{name}")
-        behaviors = []
-
-        singular = name.to_s.singularize
+        namespace = options[:namespace] || merged_params[:namespace] || conditions[:namespace]
+        
+        match_path = namespace ? "/#{namespace}/#{name}" : "/#{name}"
+        
+        next_level = match match_path
         
-        namespace = options[:namespace] || merged_params[:namespace]
+        name_prefix = options.delete :name_prefix
         
-        if options[:name_prefix].nil? && namespace != nil
-          options[:name_prefix] = "#{namespace}_"
+        if name_prefix.nil? && !namespace.nil?
+          name_prefix = namespace_to_name_prefix namespace
         end
         
-        name_prefix = options.delete(:name_prefix)
-
-
-        route_plural_name = "#{name_prefix}#{name}"
-        route_singular_name = "#{name_prefix}#{singular}"
-
-        member = options.delete(:member)
-        collection = options.delete(:collection)
-
-        # Add optional member actions
-
-        member.each_pair do |action, methods|
-          conditions = {:path => %r[^/:id[/;]#{action}$], :method => /^(#{[methods].flatten.join("|")})$/}
-          behaviors << Behavior.new(conditions, {:action => action.to_s}, next_level)
-          next_level.match("/:id/#{action}").
-            to_route.name(:"#{action}_#{route_singular_name}")
-        end if member
-
-        # Add optional collection actions
-        collection.each_pair do |action, methods|
-          conditions = {:path => %r[^[/;]#{action}$], :method => /^(#{[methods].flatten.join("|")})$/}
-          behaviors << Behavior.new(conditions, {:action => action.to_s}, next_level)
-          next_level.match("/#{action}").to_route.name(:"#{action}_#{route_plural_name}")
-        end if collection
-
         options[:controller] ||= merged_params[:controller] || name.to_s
+        
+        singular = name.to_s.singularize
+        
+        route_plural_name   = "#{name_prefix}#{name}"
+        route_singular_name = "#{name_prefix}#{singular}"
+        
+        behaviors = []
+        
+        if member = options.delete(:member)
+          member.each_pair do |action, methods|
+            behaviors << Behavior.new(
+              { :path => %r{^/:id[/;]#{action}(\.:format)?$}, :method => /^(#{[methods].flatten * '|'})$/ },
+              { :action => action.to_s }, next_level
+            )
+            next_level.match("/:id/#{action}").to_route.name(:"#{action}_#{route_singular_name}")
+          end
+        end
+        
+        if collection = options.delete(:collection)
+          collection.each_pair do |action, methods|
+            behaviors << Behavior.new(
+              { :path => %r{^[/;]#{action}(\.:format)?$}, :method => /^(#{[methods].flatten * '|'})$/ },
+              { :action => action.to_s }, next_level
+            )
+            next_level.match("/#{action}").to_route.name(:"#{action}_#{route_plural_name}")
+          end
+        end
+        
         routes = many_behaviors_to(behaviors + next_level.send(:resources_behaviors), options)
-
+        
         # Add names to some routes
-        next_level.match("").to_route.name(:"#{route_plural_name}")
-        next_level.match("/:id").to_route.name(:"#{route_singular_name}")
-        next_level.match("/new").to_route.name(:"new_#{route_singular_name}")
-        next_level.match("/:id/edit").to_route.name(:"edit_#{route_singular_name}")
-        next_level.match("/:action/:id").to_route.name(:"custom_#{route_singular_name}")
-
+        [['', :"#{route_plural_name}"],
+         ['/:id', :"#{route_singular_name}"],
+         ['/new', :"new_#{route_singular_name}"],
+         ['/:id/edit', :"edit_#{route_singular_name}"],
+         ['/:action/:id', :"custom_#{route_singular_name}"]
+        ].each do |path,name|
+          next_level.match(path).to_route.name(name)
+        end
+        
         yield next_level.match("/:#{singular}_id") if block_given?
+        
         routes
       end
-
-      def to_resource(params = {}, &block)
-        many_behaviors_to(resource_behaviors, params, &block)
-      end
-
+      
       def resource(name, options = {})
-        next_level = match("/#{name}")
-
+        namespace  = options[:namespace] || merged_params[:namespace] || conditions[:namespace]        
+        match_path = namespace ? "/#{namespace}/#{name}" : "/#{name}"
+        next_level = match match_path
+        
         options[:controller] ||= merged_params[:controller] || name.to_s
-        name_prefix = options.delete(:name_prefix)
-        routes = next_level.to_resource(options)
-
-        namespace = options[:namespace] || merged_params[:namespace] 
         
-        if options[:name_prefix].nil? && namespace != nil
-          options[:name_prefix] = "#{namespace}_"
+        # Do not pass :name_prefix option on to to_resource
+        name_prefix = options.delete :name_prefix
+        
+        if name_prefix.nil? && !namespace.nil?
+          name_prefix = namespace_to_name_prefix namespace
         end
         
+        routes = next_level.to_resource options
+        
         route_name = "#{name_prefix}#{name}"
-
-        next_level.match("").to_route.name(:"#{route_name}")
-        next_level.match("/new").to_route.name(:"new_#{route_name}")
-        next_level.match("/edit").to_route.name(:"edit_#{route_name}")
-
+        
+        next_level.match('').to_route.name(:"#{route_name}")
+        next_level.match('/new').to_route.name(:"new_#{route_name}")
+        next_level.match('/edit').to_route.name(:"edit_#{route_name}")
+        
         yield next_level if block_given?
+        
         routes
       end
-
+      
+      def to_resources(params = {}, &block)
+        many_behaviors_to resources_behaviors, params, &block
+      end
+      
+      def to_resource(params = {}, &block)
+        many_behaviors_to resource_behaviors, params, &block
+      end
+      
       def merged_original_conditions
         if parent.nil?
           @original_conditions
         else
           merged_so_far = parent.merged_original_conditions
-          path = Behavior.concat_without_endcaps(merged_so_far[:path], @original_conditions[:path])
-          path ?
-            merged_so_far.merge(@original_conditions).merge(:path => path) :
+          if path = Behavior.concat_without_endcaps(merged_so_far[:path], @original_conditions[:path])
+            merged_so_far.merge(@original_conditions).merge(:path => path)
+          else
             merged_so_far.merge(@original_conditions)
+          end
         end
       end
-
+      
       def merged_conditions
         if parent.nil?
           @conditions
         else
           merged_so_far = parent.merged_conditions
-          path = Behavior.concat_without_endcaps(merged_so_far[:path], @conditions[:path])
-          path ?
-            merged_so_far.merge(@conditions).merge(:path => path) :
+          if path = Behavior.concat_without_endcaps(merged_so_far[:path], @conditions[:path])
+            merged_so_far.merge(@conditions).merge(:path => path)
+          else
             merged_so_far.merge(@conditions)
+          end
         end
       end
-
+      
       def merged_params
         if parent.nil?
           @params
@@ -408,75 +467,82 @@ module Merb
           parent.merged_params.merge(@params)
         end
       end
-
+      
       def merged_placeholders
         placeholders = {}
         (ancestors.reverse + [self]).each do |a|
-          a.placeholders.each_pair do |key, pair|
+          a.placeholders.each_pair do |k, pair|
             param, place = pair
-            placeholders[key] = [param, place + (param == :path ? a.total_previous_captures : 0)]
+            placeholders[k] = [param, place + (param == :path ? a.total_previous_captures : 0)]
           end
         end
         placeholders
       end
-
+      
       def inspect
-        "[captures: #{path_captures}, conditions: #{@original_conditions.inspect}, params: #{@params.inspect}, placeholders: #{@placeholders.inspect}]"
+        "[captures: #{path_captures.inspect}, conditions: #{@original_conditions.inspect}, params: #{@params.inspect}, placeholders: #{@placeholders.inspect}]"
       end
-
+      
       def regexp?
         @conditions_have_regexp
       end
-
+      
     protected
+      def namespace_to_name_prefix(name_or_path)
+        name_or_path.to_s.tr('/', '_') + '_'
+      end
+      
       def resources_behaviors(parent = self)
         [
-          Behavior.new({:path => %r[^/?(\.:format)?$],     :method => :get},    {:action => "index"},   parent),
-          Behavior.new({:path => %r[^/index(\.:format)?$], :method => :get},    {:action => "index"},   parent),
-          Behavior.new({:path => %r[^/new$],               :method => :get},    {:action => "new"},     parent),
-          Behavior.new({:path => %r[^/?(\.:format)?$],     :method => :post},   {:action => "create"},  parent),
-          Behavior.new({:path => %r[^/:id(\.:format)?$],   :method => :get},    {:action => "show"},    parent),
-          Behavior.new({:path => %r[^/:id[;/]edit$],       :method => :get},    {:action => "edit"},    parent),
-          Behavior.new({:path => %r[^/:id(\.:format)?$],   :method => :put},    {:action => "update"},  parent),
-          Behavior.new({:path => %r[^/:id(\.:format)?$],   :method => :delete}, {:action => "destroy"}, parent)
+          Behavior.new({ :path => %r[^/?(\.:format)?$],     :method => :get },    { :action => "index" },   parent),
+          Behavior.new({ :path => %r[^/index(\.:format)?$], :method => :get },    { :action => "index" },   parent),
+          Behavior.new({ :path => %r[^/new$],               :method => :get },    { :action => "new" },     parent),
+          Behavior.new({ :path => %r[^/?(\.:format)?$],     :method => :post },   { :action => "create" },  parent),
+          Behavior.new({ :path => %r[^/:id(\.:format)?$],   :method => :get },    { :action => "show" },    parent),
+          Behavior.new({ :path => %r[^/:id[;/]edit$],       :method => :get },    { :action => "edit" },    parent),
+          Behavior.new({ :path => %r[^/:id(\.:format)?$],   :method => :put },    { :action => "update" },  parent),
+          Behavior.new({ :path => %r[^/:id(\.:format)?$],   :method => :delete }, { :action => "destroy" }, parent)
         ]
       end
-
+      
       def resource_behaviors(parent = self)
         [
-          Behavior.new({:path => %r{^[;/]new$},        :method => :get},    {:action => "new"},       parent),
-          Behavior.new({:path => %r{^/?(\.:format)?$}, :method => :post},   {:action => "create"},    parent),
-          Behavior.new({:path => %r{^/?(\.:format)?$}, :method => :get},    {:action => "show"},      parent),
-          Behavior.new({:path => %r{^[;/]edit$},       :method => :get},    {:action => "edit"},      parent),
-          Behavior.new({:path => %r{^/?(\.:format)?$}, :method => :put},    {:action => "update"},    parent),
-          Behavior.new({:path => %r{^/?(\.:format)?$}, :method => :delete}, {:action => "destroy"},   parent)
+          Behavior.new({ :path => %r{^[;/]new$},        :method => :get },    { :action => "new" },     parent),
+          Behavior.new({ :path => %r{^/?(\.:format)?$}, :method => :post },   { :action => "create" },  parent),
+          Behavior.new({ :path => %r{^/?(\.:format)?$}, :method => :get },    { :action => "show" },    parent),
+          Behavior.new({ :path => %r{^[;/]edit$},       :method => :get },    { :action => "edit" },    parent),
+          Behavior.new({ :path => %r{^/?(\.:format)?$}, :method => :put },    { :action => "update" },  parent),
+          Behavior.new({ :path => %r{^/?(\.:format)?$}, :method => :delete }, { :action => "destroy" }, parent)
         ]
       end
-
+      
       # Creates a series of routes from an array of Behavior objects.
       # You can pass in optional +params+, and an optional block that will be
       # passed along to the #to method.
       def many_behaviors_to(behaviors, params = {}, &conditional_block)
-        routes = []
-        behaviors.each { |b| routes << b.to(params, &conditional_block) }
-        routes
+        behaviors.map { |b| b.to params, &conditional_block }
       end
-
+      
       # Convert conditions to regular expression string sources for consistency
       def stringify_conditions
         @conditions_have_regexp = false
-        @conditions.each_pair do |key, value|
+        @conditions.each_pair do |k,v|
           # TODO: Other Regexp special chars
-          @conditions[key] = case value
-            when String then "^" + value.escape_regexp + "$"
-            when Symbol then "^" + value.to_s + "$"
-            when Regexp:
-              @conditions_have_regexp = true
-              value.source
+          
+          @conditions[k] = case v
+          when String,Symbol
+            if k == :namespace
+              v.to_s
+            else
+              "^#{v.to_s.escape_regexp}$"
             end
+          when Regexp
+            @conditions_have_regexp = true
+            v.source
+          end
         end
       end
-
+      
       def copy_original_conditions
         @original_conditions = {}
         @conditions.each_pair do |key, value|
@@ -484,60 +550,66 @@ module Merb
         end
         @original_conditions
       end
-
+      
       def deduce_placeholders
         @conditions.each_pair do |match_key, source|
           while match = SEGMENT_REGEXP.match(source)
-            source.sub!(SEGMENT_REGEXP, PARENTHETICAL_SEGMENT_STRING)
-            unless match[2] == ":" # No need to store anonymous place holders
+            source.sub! SEGMENT_REGEXP, PARENTHETICAL_SEGMENT_STRING
+            unless match[2] == ':' # No need to store anonymous place holders
               placeholder_key = match[2].intern
               @params[placeholder_key] = "#{match[1]}"
-              @placeholders[placeholder_key] = [match_key, Behavior.count_parens_up_to(source, match.offset(1)[0])]
+              @placeholders[placeholder_key] = [
+                match_key, Behavior.count_parens_up_to(source, match.offset(1)[0])
+              ]
             end
           end
         end
       end
-
+      
       def ancestors(list = [])
         if parent.nil?
           list
         else
           list.push parent
-          parent.ancestors(list)
+          parent.ancestors list
           list
         end
       end
-
+      
       # Count the number of regexp captures in the :path condition
       def path_captures
         return 0 unless conditions[:path]
         Behavior.count_parens_up_to(conditions[:path], conditions[:path].size)
       end
-
+      
       def total_previous_captures
         ancestors.map{|a| a.path_captures}.inject(0){|sum, n| sum + n}
       end
-
+      
       # def merge_with_ancestors
       #   self.class.new(merged_conditions, merged_params)
       # end
-
+      
       def compiled_conditions(conditions = merged_conditions)
-        compiled = {}
-        conditions.each { |key, value| compiled[key] = Regexp.new(value) }
-        compiled
+        conditions.inject({}) do |compiled,(k,v)|
+          compiled.merge k => Regexp.new(v)
+        end
       end
-
+      
       # Compiles the params hash into 'eval'-able form.
-      # For example:
+      # 
       #   @params = {:controller => "admin/:controller"}
+      # 
       # Could become:
-      #   {:controller => "'admin/' + matches[:path][1]"}
+      # 
+      #   { :controller => "'admin/' + matches[:path][1]" }
       #
       def compiled_params(params = merged_params, placeholders = merged_placeholders)
         compiled = {}
         params.each_pair do |key, value|
-          raise ArgumentError, "param value must be string (#{value.inspect})" unless value.is_a? String
+          unless value.is_a? String
+            raise ArgumentError, "param value must be string (#{value.inspect})"
+          end
           result = []
           value = value.dup
           match = true
@@ -568,41 +640,7 @@ module Merb
         end
         compiled
       end
-
-    public
-      # Count the number of open parentheses in +string+, up to and including +pos+
-      def self.count_parens_up_to(string, pos)
-        string[0..pos].gsub(/[^\(]/, "").size
-      end
-
-      # Concatenate strings and remove regexp end caps
-      def self.concat_without_endcaps(string1, string2)
-        return nil if !string1 and !string2
-        return string1 if string2.nil?
-        return string2 if string1.nil?
-        s1 = string1[-1] == ?$ ? string1[0..-2] : string1
-        s2 = string2[0] == ?^ ? string2[1..-1] : string2
-        s1 + s2
-      end
-
-      # Join an array's elements into a string using " + " as a joiner, and
-      # surround string elements in quotes.
-      def self.array_to_code(arr)
-        code = ""
-        arr.each_with_index do |part, i|
-          code << " + " if i > 0
-          case part
-          when Symbol
-            code << "#{part}"
-          when String
-            code << "\"" + part + "\""
-          else
-            raise "Don't know how to compile array part: #{part.class} [#{i}]"
-          end
-        end
-        code
-      end
     end # Behavior
-
+    
   end
 end