merb 0.3.4 → 0.3.7

data/lib/merb/merb_request.rb

@@ -13,7 +13,9 @@ module Merb
       @request.read
     end  
     
-    # returns true if the request is an ajax request.
+    # Returns true if the request is an Ajax request.
+    #
+    # Also aliased as the more memorable ajax? and xhr?.
     def xml_http_request?
       not /XMLHttpRequest/i.match(@env['HTTP_X_REQUESTED_WITH']).nil?
     end
@@ -24,15 +26,15 @@ module Merb
     def remote_ip
       return @env['HTTP_CLIENT_IP'] if @env.include?('HTTP_CLIENT_IP')
     
-      if @env.include?(Mongrel::Const::HTTP_X_FORWARDED_FOR) then
-        remote_ips = @env[Mongrel::Const::HTTP_X_FORWARDED_FOR].split(',').reject do |ip|
+      if @env.include?(Merb::Const::HTTP_X_FORWARDED_FOR) then
+        remote_ips = @env[Merb::Const::HTTP_X_FORWARDED_FOR].split(',').reject do |ip|
           ip =~ /^unknown$|^(127|10|172\.16|192\.168)\./i
         end
     
         return remote_ips.first.strip unless remote_ips.empty?
       end
     
-      return @env[Mongrel::Const::REMOTE_ADDR]
+      return @env[Merb::Const::REMOTE_ADDR]
     end
     
     # returns either 'https://' or 'http://' depending on

data/lib/merb/merb_router.rb

@@ -6,7 +6,7 @@ module Merb
     
     class << self
       
-      def prepare(&block)
+      def prepare
         @@matcher = RouteMatcher.new
         @@generator = RouteGenerator.new
       
@@ -31,8 +31,8 @@ module Merb
         @@matcher.route_request(path)
       end
       
-      def generate(method, options = {})
-        @@generator.generate(method, options)
+      def generate(method, *args)
+        @@generator.generate(method, *args)
       end
       
       def resources(res, opts={})
@@ -57,8 +57,8 @@ module Merb
         end
       end
       
-      def default_routes
-        @@matcher.default_routes
+      def default_routes(*a)
+        @@matcher.default_routes(*a)
       end
       
       def compiled_statement
@@ -80,32 +80,33 @@ module Merb
     end # class << self
     
     class RouteMatcher
-            
+      attr_reader :routes, :compiled_statement, :compiled_regexen
+
       def initialize
         @routes = Array.new
+        # The final compiled lambda that gets used as the body of the route_request method.
         @compiled_statement = String.new
         @compiled_regexen   = Array.new
       end
 
-      # the final compiled lambda that gets used
-      # as the body of the route_request method.
-      def compiled_statement
-        @compiled_statement
+      # Add a route to be compiled.
+      def add(*route)
+        opt = Hash === route.last ? route.pop : {}
+        if n = opt[:namespace]
+          path = "/#{n}#{route[0]}" 
+        else
+          path = route[0]
+        end    
+        @routes << [path, opt]
       end
       
-      def compiled_regexen
-        @compiled_regexen
-      end
-
-      # add a route to be compiled
-      def add(*route)
-        @routes << [route[0], (route[1] || {})]
+      def raw_add(*route)
+        @routes << [route[0], (route[1]||{})]
       end
       
-      # build up a string that defines a lambda
-      # that does a case statement on the PATH_INFO
-      # against each of the compiled routes in turn.
-      # first route that matches wins.
+      # Build up a string that defines a lambda that does a case statement on
+      # the PATH_INFO against each of the compiled routes in turn. First route
+      # that matches wins.
       def compile_router
         router_lambda = @routes.inject("lambda{|path| \n  sections={}\n  case path\n") { |m,r|
           m << compile(r)
@@ -114,11 +115,10 @@ module Merb
         meta_def(:route_request, &eval(router_lambda))
       end  
       
-      # compile each individual route into a when /.../
-      # component of the case statement. Takes /:sections
-      # of the route def that start with : and turns them
-      # into placeholders for whatever urls match against
-      # the route in question.
+      # Compile each individual route into a when /.../ component of the case
+      # statement. Takes /:sections of the route def that start with : and
+      # turns them into placeholders for whatever urls match against the route
+      # in question.
       def compile(route)
         raise ArgumentError unless String === route[0]
         code, count = '', 0
@@ -143,45 +143,48 @@ module Merb
       end
       
       def generate_resources_routes(res,opt)
-        with_options :controller => res.to_s, :rest => true do |r|
-          r.add "#{opt[:prefix]}/#{res}/:id[;/]edit", :allowed => {:get => 'edit'}
-          r.add "#{opt[:prefix]}/#{res}/new[;/]:action", :allowed => {:get => 'new', :post => 'new', :put => 'new', :delete => 'new'}
-          r.add "#{opt[:prefix]}/#{res}/new" , :allowed => {:get => 'new'}
+        with_options opt.merge(:controller => res.to_s, :rest => true) do |r|
+          r.raw_add "#{opt[:prefix]}/#{res}/:id[;/]edit", :allowed => {:get => 'edit'}
+          r.raw_add "#{opt[:prefix]}/#{res}/new[;/]:action", :allowed => {:get => 'new', :post => 'new', :put => 'new', :delete => 'new'}
+          r.raw_add "#{opt[:prefix]}/#{res}/new" , :allowed => {:get => 'new'}
           if mem = opt[:member]
             mem.keys.sort_by{|x| "#{x}"}.each {|action|
               allowed = mem[action].injecting({}) {|h, verb| h[verb] = "#{action}"}
-              r.add "#{opt[:prefix]}/#{res}/:id[;/]+#{action}", :allowed => allowed
+              r.raw_add "#{opt[:prefix]}/#{res}/:id[;/]+#{action}", :allowed => allowed
             }
           end
           if coll = opt[:collection]
             coll.keys.sort_by{|x| "#{x}"}.each {|action|
               allowed = coll[action].injecting({}) {|h, verb| h[verb] = "#{action}"}
-              r.add "#{opt[:prefix]}/#{res}[;/]#{action}", :allowed => allowed
+              r.raw_add "#{opt[:prefix]}/#{res}[;/]#{action}", :allowed => allowed
             }
           end  
-          r.add "#{opt[:prefix]}/#{res}/:id\\.:format", :allowed => {:get => 'show', :put => 'update', :delete => 'destroy'}
-          r.add "#{opt[:prefix]}/#{res}\\.:format", :allowed => {:get => 'index', :post => 'create'}
-          r.add "#{opt[:prefix]}/#{res}/:id", :allowed => {:get => 'show', :put => 'update', :delete => 'destroy'}
-          r.add "#{opt[:prefix]}/#{res}/?", :allowed => {:get => 'index', :post => 'create'}
+          r.raw_add "#{opt[:prefix]}/#{res}/:id\\.:format", :allowed => {:get => 'show', :put => 'update', :delete => 'destroy'}
+          r.raw_add "#{opt[:prefix]}/#{res}\\.:format", :allowed => {:get => 'index', :post => 'create'}
+          r.raw_add "#{opt[:prefix]}/#{res}/:id", :allowed => {:get => 'show', :put => 'update', :delete => 'destroy'}
+          r.raw_add "#{opt[:prefix]}/#{res}/?", :allowed => {:get => 'index', :post => 'create'}
         end
       end
       
       def generate_singleton_routes(res,opt)
-        with_options :controller => res.to_s, :rest => true do |r|
-          r.add "#{opt[:prefix]}/#{res}[;/]edit", :allowed => {:get => 'edit'}
-          r.add "#{opt[:prefix]}/#{res}\\.:format", :allowed => {:get => 'show'}
-          r.add "#{opt[:prefix]}/#{res}/new" , :allowed => {:get => 'new'}
-          r.add "#{opt[:prefix]}/#{res}/?", :allowed => {:get => 'show', :post => 'create', :put => 'update', :delete => 'destroy'}
+        with_options opt.merge(:controller => res.to_s, :rest => true ) do |r|
+          r.raw_add "#{opt[:prefix]}/#{res}[;/]edit", :allowed => {:get => 'edit'}
+          r.raw_add "#{opt[:prefix]}/#{res}\\.:format", :allowed => {:get => 'show'}
+          r.raw_add "#{opt[:prefix]}/#{res}/new" , :allowed => {:get => 'new'}
+          r.raw_add "#{opt[:prefix]}/#{res}/?", :allowed => {:get => 'show', :post => 'create', :put => 'update', :delete => 'destroy'}
         end
       end
       
-      def default_routes
-        add "/:controller/:action/:id\\.:format"
-        add "/:controller/:action/:id"
-        add "/:controller/:action\\.:format"
-        add "/:controller/:action"
-        add "/:controller\\.:format", :action => 'index'
-        add "/:controller", :action => 'index'
+      def default_routes(opt={})
+        namespace = opt[:namespace] ? "/#{opt[:namespace]}" : ""
+        with_options opt do |r|
+          r.raw_add namespace + "/:controller/:action/:id\\.:format"
+          r.raw_add namespace + "/:controller/:action/:id"
+          r.raw_add namespace + "/:controller/:action\\.:format"
+          r.raw_add namespace + "/:controller/:action"
+          r.raw_add namespace + "/:controller\\.:format", :action => 'index'
+          r.raw_add namespace + "/:controller", :action => 'index'
+        end  
       end
     end
 
@@ -194,14 +197,29 @@ module Merb
       end
 
       def add(name, path)
-        name = name.intern unless Symbol === name
-        @paths[name] = path
+        @paths[name.to_sym] = path
       end
-
-      def generate(name, options = {})
+      
+      def generate(name, *args)
+        options = Hash === args.last ? args.pop : {}
+        obj = args[0]
+        options.each do |key, value|
+          next unless value.respond_to?(:to_param)
+          unless key.to_s =~ /_?id$/
+            old_key = key
+            options[old_key] = value.to_param
+            key = "#{key}_id".intern
+          end
+          options[key] = value.to_param
+        end  
+        
         path = @paths[name].dup
         while path =~ Router::SECTION_REGEXP
-          path.sub!(Router::SECTION_REGEXP, options[$~[1].intern].to_s)
+          if obj.respond_to?($1) && ! obj.nil?
+            path.sub!(Router::SECTION_REGEXP, obj.send($1).to_s)
+          else  
+            path.sub!(Router::SECTION_REGEXP, options[$1.intern].to_s)
+          end
         end
         if f = options[:format]
           "#{path}.#{f}"
@@ -209,28 +227,44 @@ module Merb
           path
         end   
       end
-
+      
       def generate_singleton_routes(res,opt)
-        add "edit_#{res}", "#{opt[:prefix]}/#{res}/edit"
-        add "new_#{res}","#{opt[:prefix]}/#{res}/new"
-        add res, "#{opt[:prefix]}/#{res}"
+        res = res.to_s
+        if opt[:namespace]
+          namespace = "#{opt[:namespace]}_"
+          name = "/#{opt[:namespace]}"
+        else
+          namespace = ''
+          name = ''
+        end
+        add namespace + "edit_#{res}", name + "#{opt[:prefix]}/#{res}/edit"
+        add namespace + "new_#{res}", name + "#{opt[:prefix]}/#{res}/new"
+        add namespace + res, name + "#{opt[:prefix]}/#{res}"
       end
       
       def generate_resources_routes(res,opt)
-        res_singular = res.to_s.singularize
-        add res,                    "#{opt[:prefix]}/#{res}"
-        add res_singular,           "#{opt[:prefix]}/#{res}/:id"
-        add "new_#{res_singular}",  "#{opt[:prefix]}/#{res}/new"
-        add "custom_new_#{res_singular}",  "#{opt[:prefix]}/#{res}/new/:action"
-        add "edit_#{res_singular}", "#{opt[:prefix]}/#{res}/:id/edit"
+        res = res.to_s
+        res_singular = res.singularize
+        if opt[:namespace]
+          namespace = "#{opt[:namespace]}_"
+          name = "/#{opt[:namespace]}"
+        else
+          namespace = ''
+          name = ''
+        end  
+        add namespace + res,                    name + "#{opt[:prefix]}/#{res}"
+        add namespace + res_singular,           name + "#{opt[:prefix]}/#{res}/:id"
+        add namespace + "new_#{res_singular}",  name + "#{opt[:prefix]}/#{res}/new"
+        add namespace + "custom_new_#{res_singular}",  name + "#{opt[:prefix]}/#{res}/new/:action"
+        add namespace + "edit_#{res_singular}", name + "#{opt[:prefix]}/#{res}/:id/edit"
         if mem = opt[:member]
           mem.keys.sort_by{|x| "#{x}"}.each {|action|
-            add "#{action}_#{res_singular}", "#{opt[:prefix]}/#{res}/:id/#{action}"
+            add namespace + "#{action}_#{res_singular}", name + "#{opt[:prefix]}/#{res}/:id/#{action}"
           }
         end
         if coll = opt[:collection]
           coll.keys.sort_by{|x| "#{x}"}.each {|action|
-            add "#{action}_#{res_singular}", "#{opt[:prefix]}/#{res}/#{action}"
+            add namespace + "#{action}_#{res_singular}", name + "#{opt[:prefix]}/#{res}/#{action}"
           }
         end
       end

data/lib/merb/merb_server.rb

@@ -15,7 +15,9 @@ module Merb
         :allow_reloading => true,
         :merb_root => Dir.pwd,
         :cache_templates => false,
-        :use_mutex => true
+        :use_mutex => true,
+        :session_id_cookie_only => true,
+        :query_string_whitelist => []
       }
       begin
         options = defaults.merge(YAML.load(Erubis::Eruby.new(IO.read("#{defaults[:merb_root]}/dist/conf/merb.yml")).result))
@@ -36,9 +38,9 @@ module Merb
       
         opts = OptionParser.new do |opts|
           opts.banner = "Usage: merb [fdcepghmisluMG] [argument]"
-          opts.define_head "Merb Mongrel+ Erb. Lightweight replacement for ActionPack"
+          opts.define_head "Merb Mongrel+ Erb. Lightweight replacement for ActionPack."
           opts.separator '*'*80
-          opts.separator 'If no flags are given, Merb starts in the foreground on port 4000'
+          opts.separator 'If no flags are given, Merb starts in the foreground on port 4000.'
           opts.separator '*'*80
 
           opts.on("-u", "--user USER", "This flag is for having merb run as a user other than the one currently logged in. Note: if you set this you must also provide a --group option for it to take effect.") do |config|
@@ -49,27 +51,27 @@ module Merb
             options[:group] = config
           end
                     
-          opts.on("-f", "--config-file FILENAME", "This flag is for adding extra config files for things like the upload progress module") do |config|
+          opts.on("-f", "--config-file FILENAME", "This flag is for adding extra config files for things like the upload progress module.") do |config|
             options[:config] = config
           end
           
-          opts.on("-d", "--daemonize", "This will run a single merb in the background") do |config|
+          opts.on("-d", "--daemonize", "This will run a single merb in the background.") do |config|
             options[:daemonize] = true
           end
           
-          opts.on("-c", "--cluster-nodes NUM_MERBS", "Number of merb daemons to run") do |nodes|
+          opts.on("-c", "--cluster-nodes NUM_MERBS", "Number of merb daemons to run.") do |nodes|
             options[:cluster] = nodes
           end
       
-          opts.on("-p", "--port PORTNUM", "Port to run merb on, defaults to 4000") do |port|
+          opts.on("-p", "--port PORTNUM", "Port to run merb on, defaults to 4000.") do |port|
             options[:port] = port
           end
       
-          opts.on("-h", "--host HOSTNAME", "Host to bind to(default is all IP's)") do |host|
+          opts.on("-h", "--host HOSTNAME", "Host to bind to (default is all IP's).") do |host|
             options[:host] = host
           end
       
-          opts.on("-m", "--merb-root MERB_ROOT", "the path to the MERB_ROOT for the app you want to run") do |merb_root|
+          opts.on("-m", "--merb-root MERB_ROOT", "The path to the MERB_ROOT for the app you want to run (default is current working dir).") do |merb_root|
             options[:merb_root] = File.expand_path(merb_root)
           end
           
@@ -77,7 +79,7 @@ module Merb
             options[:console] = true
           end
           
-          opts.on("-s", "--start-drb PORTNUM", "This is the port number to run the drb daemon on for sessions and uplod progress monitoring.") do |drb_port|
+          opts.on("-s", "--start-drb PORTNUM", "This is the port number to run the drb daemon on for sessions and upload progress monitoring.") do |drb_port|
             options[:start_drb] = true
             options[:only_drb] = true
             options[:drb_server_port] = drb_port
@@ -91,19 +93,23 @@ module Merb
             options[:environment] = env
           end
           
-          opts.on("-r", "--script-runner ['RUBY CODE'| FULL_SCRIPT_PATH]", "Command-line option to run scripts and/or code in the merb app") do |stuff_to_run|
+          opts.on("-r", "--script-runner ['RUBY CODE'| FULL_SCRIPT_PATH]", "Command-line option to run scripts and/or code in the merb app.") do |stuff_to_run|
             options[:runner] = stuff_to_run
           end
           
-          opts.on("-g", "--generate-app PATH", "Generate a fresh merb app at PATH") do |path|
+          opts.on("-g", "--generate-app PATH", "Generate a fresh merb app at PATH.") do |path|
             options[:generate] = path || Dir.pwd
           end
           
-          opts.on("-k", "--kill PORT or all", "Kill one merb proceses by port number. use merb -k all to kill all merbs") do |ports|
+          opts.on("-P", "--plugin ACTION NAME", "Do ACTION with a plugin called NAME.") do |action|
+            options[:plugin] = [action, ARGV] || nil
+          end
+          
+          opts.on("-k", "--kill PORT or all", "Kill one merb proceses by port number. use merb -k all to kill all merbs.") do |ports|
             options[:kill] = ports
           end
           
-          opts.on("-M", "--merb-config FILENAME", "This flag is for explicitly declaring the merb app's config file") do |config|
+          opts.on("-M", "--merb-config FILENAME", "This flag is for explicitly declaring the merb app's config file.") do |config|
             options[:merb_config] = config
           end
          
@@ -131,9 +137,28 @@ module Merb
         # or if we add :merb_root: /path/to/merb/app in the merb.yml we can now only call it 
         # like so: merb --merb-config /path/to/dist/conf/merb.yml
         if options[:merb_config]
+          # Check and see if an environment has been set through the CLI
+          # if so, save it in a temp. In this case, if merb.yml has an :environment:
+          # set... it will be overwritten by the CLI. [Rogelio J. Samour] 2007-06-07
+          if options[:environment]
+            temp_env = options[:environment]
+          end
           options = options.merge(YAML.load(Erubis::Eruby.new(IO.read("#{options[:merb_config]}")).result))
+          if temp_env
+            options[:environment] = temp_env
+          end
         end
       
+        if ENV['MERB_ENV']
+          # ENV['MERB_ENV'] has precedence over all
+          options[:environment] = ENV['MERB_ENV']
+        end
+
+        # Finally, if all else fails... set the environment to 'development'
+        if options[:environment].nil?
+          options[:environment] = 'development'
+        end
+
         @@merb_opts = options
       end
       
@@ -141,6 +166,7 @@ module Merb
         require 'merb'
         require @@merb_opts[:merb_root] / 'dist/conf/router.rb'
         require @@merb_opts[:merb_root] / 'dist/conf/merb_init.rb'
+
       end  
       
       def run
@@ -180,8 +206,8 @@ module Merb
         end  
         
         @@merb_opts[:dist_root] = @@merb_opts[:merb_root]+'/dist' 
-        $LOAD_PATH.unshift( File.join(@@merb_opts[:dist_root] , '/app/controllers') )
         $LOAD_PATH.unshift( File.join(@@merb_opts[:dist_root] , '/app/models') )
+        $LOAD_PATH.unshift( File.join(@@merb_opts[:dist_root] , '/app/controllers') )
         $LOAD_PATH.unshift( File.join(@@merb_opts[:dist_root] , '/lib') )
         if File.exist? File.join(@@merb_opts[:dist_root] , '/framework')
           $LOAD_PATH.unshift( File.join(@@merb_opts[:dist_root] , '/framework') )
@@ -193,17 +219,35 @@ module Merb
           exit!
         end  
         
+        if @@merb_opts[:plugin]
+          require 'merb/merb_plugins'
+          ::Merb::PluginManager.action(@@merb_opts[:plugin].shift, @@merb_opts[:plugin][0].shift, @@merb_opts[:plugin])
+          exit!
+        end
+        
         if @@merb_opts[:console]
           initialize_merb
-          Object.class_eval do 
-            def show_routes
-              Merb::Router.generator.paths.each {|p| puts p.inspect}
+          _merb = Class.new do
+            def self.show_routes(all_opts = false)
+              puts "== show_routes(all_opts = #{all_opts}) =="
+              puts "RouteMatcher:"
+              Merb::Router.matcher.routes.each {|route,opts| puts "  #{route}" + (all_opts ? " " + opts.inspect : "") }
+              puts
+              puts "RouteGenerator:"
+              # Sort alphabetically by the url part of the route for easier reading.
+              Merb::Router.generator.paths.sort {|a,b| a.last <=> b.last }.each {|p| puts "  " + p.inspect}
               nil
             end
-            def url(path, o={})
-              Merb::Router.generator.generate(path,o)
+            
+            def self.url(path, *args)
+              Merb::Router.generate(path,*args)
             end
           end
+          
+          Object.send(:define_method, :merb) {
+            _merb
+          }  
+            
           ARGV.clear # Avoid passing args to IRB 
           require 'irb' 
           require 'irb/completion' 
@@ -306,7 +350,7 @@ module Merb
           listener do
             uri( "/", :handler => MerbUploadHandler.new(yconfig), :in_front => true) if @@merb_opts[:config]
             uri "/", :handler => MerbHandler.new(@@merb_opts[:dist_root]+'/public')
-            uri "/favicon.ico", :handler => Mongrel::Error404Handler.new("")
+            uri "/favicon.ico", :handler => Mongrel::Error404Handler.new("") 
           end
       
           trap("INT") { stop }