merb 0.0.3 → 0.0.4

data/lib/merb/merb_controller.rb

@@ -1,19 +1,21 @@
 module Merb
   
-  # controller class for the merb pocket-framework. All of your
-  # controllers will inherit from Merb::Controller. This superclass
-  # takes care of parsing the incoming headers and body into params
-  # and cookies and headers. If the request is a file upload it will
+  # All of your controllers will inherit from Merb::Controller. This 
+  # superclass takes care of parsing the incoming headers and body into 
+  # params and cookies and headers. If the request is a file upload it will
   # stream it into a tempfile and pass in the filename and tempfile object
   # to your controller via params. It also parses the ?query=string and
   # puts that into params as well.
   class Controller
+    
     attr_accessor :status
-    # Stolen from Camping without a twinge of remorse ;)
-    def initialize(req, env, method=(env['REQUEST_METHOD']||"GET")) #:nodoc:
+    
+    
+    def initialize(req, env, args, method=(env['REQUEST_METHOD']||"GET")) #:nodoc:
       env = MerbHash[env.to_hash]
       puts env.inspect if $DEBUG
       puts req.inspect if $DEBUG
+      @layout = 'application'
       @status, @method, @env, @headers, @root = 200, method.downcase, env, 
           {'Content-Type'=>'text/html'}, env['SCRIPT_NAME'].sub(/\/$/,'')
       @k = query_parse(env['HTTP_COOKIE'], ';,')
@@ -54,7 +56,18 @@ module Merb
       elsif @method == "post"
         qs.merge!(query_parse(@in.read))
       end
-      @cookies, @params = @k.dup, qs.dup
+      @cookies, @params = @k.dup, qs.dup.merge(args)
+    end
+
+    def redirect(url)
+      @status = 302
+      @headers.merge!({'Location'=> url})
+      return ''
+    end
+
+    def send_file(file)
+      headers['X-SENDFILE'] = file
+      return
     end
 
     def params
@@ -85,20 +98,46 @@ module Merb
     def unescape(s)
       Mongrel::HttpRequest.unescape(s)
     end
-
-    def self.template_dir(loc)
-      @@template_dir = File.expand_path(Merb::Server.config[:merb_root] + "/app/views/#{loc}")
+ 
+  
+    def template_dir(loc)
+      File.expand_path(Merb::Server.config[:merb_root] + "/dist/app/views/#{loc}")
     end  
     
     def current_method_name(depth=0)
-      caller[depth] =~ /`(.*)'$/
-      $1
+      caller[depth] =~ /`(.*)'$/; $1
+    end
+
+    
+    def layout(l)
+       @layout = l 
     end
     
-    def render(template=current_method_name(1),b=binding)
-      template = ERB.new( IO.read( @@template_dir + "/#{template}.rhtml" ) ) 
-      template.result( b )
+    def render_no_layout(template=current_method_name(1), b=binding)
+      template = Erubis::Eruby.new( IO.read( template_dir(self.class.name.snake_case) + "/#{template}.rhtml" ) ) 
+      template.result(b)
     end  
+    
+    def render(template=current_method_name(1), b=binding)
+      name = self.class.name.snake_case
+      template = Erubis::Eruby.new( IO.read( template_dir(name) + "/#{template}.rhtml" ) ) 
+      layout_content = template.result(b)
+      return layout_content if (@layout.to_s == 'none')
+      if ['application', name].include?(@layout.to_s)
+        if File.exist?(template_dir("layout/#{name}.rhtml"))
+          layout = name
+        else
+          layout = 'application'
+        end
+      else
+        layout = @layout.to_s
+      end
+      @layout_content = layout_content
+      layout_tmpl = Erubis::Eruby.new( IO.read( template_dir('layout') + "/#{layout}.rhtml" ) )      
+      layout_tmpl.result(b)
+    end  
+
+    
   end  
   
 end

data/lib/merb/merb_daemon.rb

@@ -1,5 +1,4 @@
 require 'rubygems'
-require 'daemons'
 require 'merb'
 require 'optparse'
 require 'ostruct'
@@ -7,11 +6,6 @@ require 'ostruct'
 module Merb
 end
 
-module Daemons
-  class Controller
-    attr_accessor :app_part
-  end
-end
 
 class Merb::Server
 
@@ -36,7 +30,11 @@ class Merb::Server
       end
 
       opts.on("-m", "--merb-root [String]") do |merb_root|
-        options[:merb_root] = merb_root
+        options[:merb_root] = File.expand_path(merb_root)
+      end
+      
+      opts.on("-i", "--irb-console [String]") do |console|
+        options[:console] = true
       end
     end
 
@@ -44,6 +42,8 @@ class Merb::Server
 
 
     @@merb_opts = options
+    puts %{Merb started with these options:}
+    puts @@merb_opts.to_yaml; puts
   end
 
   def self.run
@@ -53,19 +53,33 @@ class Merb::Server
       :dir_mode => :normal
     }
 
-    @@merb_raw_opts = Daemons::Controller.new(options, ARGV).app_part
+    @@merb_raw_opts = ARGV
     merb_config
-
-      require @@merb_opts[:merb_root]+'/conf/router.rb'
-      require @@merb_opts[:merb_root]+'/conf/merb_init.rb'
-      $LOAD_PATH.unshift( File.join(@@merb_opts[:merb_root] , 'app/controllers') )
-      $LOAD_PATH.unshift( File.join(@@merb_opts[:merb_root] , 'lib') )
-
-
-      h = Mongrel::HttpServer.new((@@merb_opts[:host]||"0.0.0.0"), (@@merb_opts[:port]||4000), (@@merb_opts[:numprocs]||40))
-      h.register("/", MerbHandler.new(@@merb_opts[:merb_root]+'/public'))
-      h.register("/favicon.ico", Mongrel::Error404Handler.new(""))
-      h.run.join
+    
+    @@merb_opts[:dist_root] = @@merb_opts[:merb_root]+'/dist' 
+    
+    $LOAD_PATH.unshift( File.join(@@merb_opts[:merb_root] , '/dist/app/controllers') )
+    $LOAD_PATH.unshift( File.join(@@merb_opts[:merb_root] , '/dist/lib') )
+    require @@merb_opts[:merb_root]+'/dist/conf/router.rb'
+    require @@merb_opts[:merb_root]+'/dist/conf/merb_init.rb'
+
+    if  @@merb_opts[:console]
+     ARGV.clear # Avoid passing args to IRB 
+     require 'irb' 
+     require 'irb/completion' 
+     def exit
+       exit!
+     end   
+     if File.exists? ".irbrc"
+       ENV['IRBRC'] = ".irbrc"
+     end
+     IRB.start 
+    end
+       
+    h = Mongrel::HttpServer.new((@@merb_opts[:host]||"0.0.0.0"), (@@merb_opts[:port]||4000))#, (@@merb_opts[:numprocs]||40))
+    h.register("/", MerbHandler.new(@@merb_opts[:dist_root]+'/public'))
+    h.register("/favicon.ico", Mongrel::Error404Handler.new(""))
+    h.run.join
     
   end
 
@@ -73,4 +87,5 @@ class Merb::Server
     @@merb_opts
   end  
 
-end
+end
+

data/lib/merb/merb_handler.rb

@@ -1,3 +1,4 @@
+require 'sync'
 class MerbHandler < Mongrel::HttpHandler
   @@file_only_methods = ["GET","HEAD"]
   
@@ -6,6 +7,7 @@ class MerbHandler < Mongrel::HttpHandler
   # by default. See merb_daemon.rb if you want to change this.
   def initialize(dir, opts = {})
     @files = Mongrel::DirHandler.new(dir,false)
+    @guard = Sync.new
   end
   
   # process incoming http requests and do a number of things
@@ -43,37 +45,37 @@ class MerbHandler < Mongrel::HttpHandler
       @files.process(request,response)
     else
       begin
-        controller, method, args = handle(request)
-        output = if (controller && controller.kind_of?(Merb::Controller))
-          if method
-            ( args ? controller.send( method, args ) : controller.send(method) )
+        # This handles parsing the query string and post/file upload
+        # params and is outside of the synchronize call so that
+        # multiple file uploads can be done at once.
+        controller, action = handle(request)
+        p controller, action
+        output = nil
+        # synchronize here because this is where ActiveRecord or your db
+        # calls will be run in your controller methods.
+        @guard.synchronize(:EX) {
+          output = if (controller && controller.kind_of?(Merb::Controller))
+            if action
+              controller.send(action)
+            else
+              controller.to_s
+            end  
           else
-            controller.to_s
-          end  
-        else
-          nil
-        end
+            nil
+          end
+        }
       rescue Exception => e
         response.start(500) do |head,out|
           head["Content-Type"] = "text/html"
-          out <<"<html><h2>Merb Error!</h2><pre>#{ e.message } - (#{ e.class })" << 
-          "\n" << "#{(e.backtrace or []).join('\n')}</pre></html>"
+          out << exception(e)
         end  
         return
-      end  
-      
-      unless output
-        response.start(404) do |head,out|
-          head["Content-Type"] = "text/html"
-          out << "<html><body>Error: no merb controller found for this url.</body></html>"
-        end
-        return
-      end  
+      end   
       
       sendfile, clength = nil
       response.status = controller.status
       
-      # check for the X-SENDFILE heaqder from your Merb::Controller
+      # check for the X-SENDFILE header from your Merb::Controller
       # and serve the file directly instead of buffering.
       controller.headers.each do |k, v|
         if k =~ /^X-SENDFILE$/i
@@ -99,39 +101,48 @@ class MerbHandler < Mongrel::HttpHandler
         response.write(output)
       end
     end
-  end  
-  
+  end    
+    
   # This is where we grab the incoming request PATH_INFO
   # and use that in the merb routematcher to determine
-  # which controller and method to run.
+  # which controller and method to run. 
+  # returns a 2 element tuple of:
+  # [controller_object, method]
   def handle(request)
-    path = request.params["PATH_INFO"].sub(/\/+/, '/')
+    path = request.params[Mongrel::Const::PATH_INFO].sub(/\/+/, '/')
     path = path[0..-2] if (path[-1] == ?/)
-    routes = Merb::RouteMatcher.new
-    route = routes.route_request(path)
+    route = Merb::RouteMatcher.new.route_request(path)
+    puts route.inspect if $DEBUG
     if route
-      [ instantiate_controller(route.delete(:class), request.body, request.params), 
-                               route.delete(:method), route  ]
+      [ instantiate_controller(route[:controller], request.body, request.params, 
+                               route.dup.delete_if{|k,v| [:controller, :action].include? k}), 
+                               route[:action]]
     else  
-      ["<html><body>Error: no route matches!</body></html>", nil, nil]
+      ["<html><body>Error: no route matches!</body></html>", nil]
     end
   end
   
   # take a controller class name string and reload or require
   # the right controller file then upcase the first letter and
-  # trun it into a new object p[assing in the request and response.
+  # trun it into a new object passing in the request and response.
   # this is where your Merb::Controller is instantiated.
-  def instantiate_controller(controller_name, req, env)
-    if !File.exist?(Merb::Server.config[:merb_root]+"/app/controllers/#{controller_name}.rb")
-      return Object.const_get(:Noroutefound).new(req, env)
-    end  
-    controller_name.import
+  def instantiate_controller(controller_name, req, env, params) 
+    if !File.exist?(Merb::Server.config[:dist_root]+"/app/controllers/#{controller_name.snake_case}.rb")
+      return Object.const_get(:Noroutefound).new(req, env, params)
+    end
     begin
-      return Object.const_get( controller_name.controller_class_name ).new(req, env)
+      controller_name.import
+      return Object.const_get( controller_name.camel_case ).new(req, env, params)
     rescue Exception
-      warn "Error getting instance of '#{controller_name.controller_class_name}': #{$!}"
+      warn "Error getting instance of '#{controller_name.camel_case}': #{$!}"
       raise $!
     end
   end
     
+  # format exception message for browser display  
+  def exception(e)
+    "<html><h2>Merb Error!</h2><p>#{ e.message } - (#{ e.class })\n" << 
+    "#{(e.backtrace or []).join('<br />')}</p></html>"
+  end  
+    
 end

data/lib/merb/merb_router.rb

@@ -1,34 +1,19 @@
 module Merb
   
   # Merb::RouteMatcher is the request routing mapper for the merb framework.
-  # You can define placeholder parts of the url with the :smbol notation.
+  # You can define placeholder parts of the url with the :symbol notation.
   # so r.add '/foo/:bar/baz/:id', :class => 'Bar', :method => 'foo'
   # will match against a request to /foo/123/baz/456. It will then
   # use the class Bar as your merb controller and call the foo method on it. 
   # the foo method will recieve a hash with {:bar => '123', :id => '456'}
   # as the content. So the :placeholders sections of your routes become
-  # a hash of arguments to your controller methods. These two methods map
-  # the default /controller/action and /controller/action/id urls you will 
-  # use so you will want these two by default, in this order:
-  # r.add '/:class/:method/:id', {}
-  # r.add '/:class/:method', {}
-  #
-  # This is what a route prepare definition looks like. I have added
-  # code that will spit out the compiled routing lambda so you can see 
-  # what is generated:
-  #
-  # puts "Compiling routes: \n"
-  # Merb::RouteMatcher.prepare do |r|
-  #   r.add '/foo/:bar/baz/:id', :class => 'Test', :method => 'foo'
-  #   r.add '/:class/:method/:id', {}
-  #   r.add '/:class/:method', {}
-  # end
-  # m = Merb::RouteMatcher.new
-  # puts m.compiled_statement
+  # a hash of arguments to your controller methods. This route maps
+  # the default /controller/action and /controller/action/id urls:
+  # r.add '/:class/:method/:id'
   class RouteMatcher
     
     attr_accessor :sections
-    SECTION_REGEX = /(?::([a-z]+))/ unless defined?SECTION_REGEX
+    @@section_regexp = /(?::([a-z*]+))/.freeze
     
     def self.prepare
       @@routes = Array.new
@@ -50,30 +35,42 @@ module Merb
     end
   
     def self.add(*route)
-      @@routes << route
+      @@routes << [route[0], (route[1] || {})]
     end
     
     def self.compile_router
-      router_lambda = @@routes.inject('lambda{|path| ') { |m,r|
+      router_lambda = @@routes.inject("lambda{|path| \n  case path\n") { |m,r|
         m << compile(r)
-      } << "\n  return {:class=>'NoRouteFound', :method=>'noroute'}\n}"
+      } <<"  else\n    return {:controller=>'Noroutefound', :action=>'noroute'}\n  end\n}"
       @@compiled_statement = router_lambda
       define_method(:route_request, &eval(router_lambda))
     end  
     
     def self.compile(route)
       raise ArgumentError unless String === route[0]
+      if route[0] == '/:controller/:action/:id'
+        return '  when /\A\/([^\/;.,?]+)(?:\/?\Z|\/([^\/;.,?]+)\/?)(?:\/?\Z|\/([^\/;.,?]+)\/?)\Z/
+      @sections[:controller] = $1
+      @sections[:action] = $2 || \'index\'
+      @sections[:id] = $3 || nil
+      return @sections'<<"\n"
+      end
       code, count = '', 0
-      while route[0] =~ SECTION_REGEX
+      while route[0] =~ @@section_regexp
         route[0] = route[0].dup
         name = $1
+        (name =~ /(\*+)(\w+)/) ? (flag = true; name = $2) : (flag = false)
         count += 1
-        route[0].sub!(SECTION_REGEX, '(.+)')
+        if flag
+          route[0].sub!(@@section_regexp, "([^;.,?]+)")
+        else  
+          route[0].sub!(@@section_regexp, "([^\/;.,?]+)")
+        end
         code << "    @sections[:#{name}] = $#{count}\n"
       end  
-      condition = "  if Regexp.new('#{route[0]}') =~ path"
-      statement = "\n#{condition}\n#{code}"
-      statement << "    return #{route[1].inspect}.merge(@sections)\n  end\n"
+      condition = "  when Regexp.new('#{route[0]}')"
+      statement = "#{condition}\n#{code}"
+      statement << "    return #{route[1].inspect}.merge(@sections)\n"
       statement
     end
           

data/lib/merb/merb_utils.rb

@@ -1,21 +1,110 @@
 class String
   def import
-    Merb::Server.config[:allow_reloading] ? load(  self  + '.rb' ) : require(  self )
+    Merb::Server.config[:allow_reloading] ? load(  self.snake_case  + '.rb' ) : require(  self.snake_case )
   end
-
-  def controller_class_name
-    self.capitalize
+  
+  def snake_case
+    return self unless self =~ %r/[A-Z]/
+    self.reverse.scan(%r/[A-Z]+|[^A-Z]*[A-Z]+?/).reverse.map{|word| word.reverse.downcase}.join '_'
   end
-end
 
-class MerbHash < HashWithIndifferentAccess
-  def method_missing(m,*a)
-      m.to_s=~/=$/?self[$`]=a[0]:a==[]?self[m]:raise(NoMethodError,"#{m}")
+
+  def camel_case
+    return self if self =~ %r/[A-Z]/ and self !~ %r/_/
+    words = self.strip.split %r/\s*_+\s*/
+    words.map!{|w| w.downcase.sub(%r/^./){|c| c.upcase}}
+    words.join
   end
+  
 end
 
 class Symbol
   def to_s
     @str_rep || (@str_rep = id2name.freeze)
   end
-end  
+  def to_proc
+     Proc.new{|*args| args.shift.__send__(self, *args)}
+   end
+end  
+
+class Object
+  def returning(value)
+    yield(value)
+    value
+  end
+end
+
+class Hash
+  def with_indifferent_access
+    MerbHash.new(self)
+  end
+end  
+
+class MerbHash < Hash
+  def initialize(constructor = {})
+    if constructor.is_a?(Hash)
+      super()
+      update(constructor)
+    else
+      super(constructor)
+    end
+  end
+ 
+  def default(key)
+    self[key.to_s] if key.is_a?(Symbol)
+  end  
+
+  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+  alias_method :regular_update, :update unless method_defined?(:regular_update)
+  
+  def []=(key, value)
+    regular_writer(convert_key(key), convert_value(value))
+  end
+
+  def update(other_hash)
+    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+    self
+  end
+  
+  alias_method :merge!, :update
+
+  def key?(key)
+    super(convert_key(key))
+  end
+
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  def fetch(key, *extras)
+    super(convert_key(key), *extras)
+  end
+
+  def values_at(*indices)
+    indices.collect {|key| self[convert_key(key)]}
+  end
+
+  def dup
+    MerbHash.new(self)
+  end
+  
+  def merge(hash)
+    self.dup.update(hash)
+  end
+
+  def delete(key)
+    super(convert_key(key))
+  end
+    
+  def method_missing(m,*a)
+      m.to_s=~/=$/?self[$`]=a[0]:a==[]?self[m]:raise(NoMethodError,"#{m}")
+  end
+    
+  protected
+    def convert_key(key)
+      key.kind_of?(Symbol) ? key.to_s : key
+    end
+    def convert_value(value)
+      value.is_a?(Hash) ? value.with_indifferent_access : value
+    end
+end  

data/{examples/sample_app/app/controllers → lib/merb}/noroutefound.rb

@@ -1,6 +1,6 @@
 class Noroutefound < Merb::Controller
 
-  def method_missing(*args)
+  def method_missing(sym, *args, &blk)
     "<html><body><h1>No Matching Route</h1></body></html>"    
   end  
   

data/lib/merb.rb

@@ -1,13 +1,13 @@
 require 'rubygems'
 require 'mongrel'
 require 'fileutils'
-require 'erb'
+require 'erubis'
 require 'merb_config'
-require 'active_support'
+
 
 module Merb
-  VERSION='0.0.3' unless defined?VERSION
+  VERSION='0.0.4' unless defined?VERSION
 end
 
 lib = File.join(File.dirname(__FILE__), 'merb')
-Dir.foreach(lib) {|fn| require File.join(lib, fn) if fn =~ /\.rb$/}
+Dir.foreach(lib) {|fn| require File.join(lib, fn) if fn =~ /\.rb$/}

data/lib/merb_config.rb

@@ -11,7 +11,7 @@ class Merb::Config
     }
 
     begin
-      options = defaults.merge(YAML.load(ERB.new(IO.read("#{defaults[:merb_root]}/conf/merb.yml")).result))
+      options = defaults.merge(YAML.load(ERB.new(IO.read("#{defaults[:merb_root]}/dist/conf/merb.yml")).result))
     rescue
       options = defaults
     end

data/test/unit/route_matcher_test.rb

@@ -10,13 +10,9 @@ class RouteMatcherTest < Test::Unit::TestCase
   
   def setup
     Merb::RouteMatcher.prepare do |r|
-      r.add '/foo/:bar/baz/:id', :class => 'Test', :method => 'foo'
-      r.add '/hey/:there/you/:guys', :class => 'Test', :method => 'hello'
-      r.add '/these/:routes/are/:sweet', :class => 'Upload', :method => 'start'
-      r.add '/h/:a/b/:c/d/:f/g/:id', :class => 'Test'
-      r.add '/:class/:method/:id', {}
-      r.add '/:class/:method', {}
-      r.add '.*', {:class => 'NoRouteFound', :method => 'noroute'}
+      r.add '/foo/:bar/baz/:id', :controller => 'Test', :action => 'foo'
+      r.add '/:controller/:action/:id'
+      r.add '/bar/:*rest', :controller => 'Test', :action => 'glob'
     end
   end  
   
@@ -30,35 +26,20 @@ class RouteMatcherTest < Test::Unit::TestCase
   
   def test_route_matching
     routes = Merb::RouteMatcher.new
-    assert_same_hash( {:class=>"Test", :id =>"456", :bar =>"123", :method=>"foo"}, routes.route_request("/foo/123/baz/456"))
+    assert_same_hash( {:controller=>"Test", :id =>"456", :bar =>"123", :action=>"foo"}, routes.route_request("/foo/123/baz/456"))
     routes = Merb::RouteMatcher.new
-    assert_same_hash( {:class=>"Test", :guys =>"girls", :there =>"jon", :method=>"hello"},  routes.route_request( "/hey/jon/you/girls"))
+    assert_same_hash({:controller=>"upload", :id=>"12", :action=>"test"},routes.route_request( "/upload/test/12"))
     routes = Merb::RouteMatcher.new
-    assert_same_hash({:class=>"upload", :id=>"12", :method=>"test"},routes.route_request( "/upload/test/12"))
+    assert_same_hash({:controller=>"upload", :id=>nil, :action=>"index"},routes.route_request( "/upload"))
     routes = Merb::RouteMatcher.new
-    assert_same_hash({:class=>"nik",  :method=>"nak"},routes.route_request( "/nik/nak"))
+    assert_same_hash({:controller=>"nik",  :action=>"nak", :id => nil},routes.route_request( "/nik/nak"))
     routes = Merb::RouteMatcher.new
-    assert_same_hash({:class=>"lots",  :method=>"of", :id => "12"},routes.route_request( "/lots/of/12"))
-    routes = Merb::RouteMatcher.new
-    assert_same_hash({:class => 'NoRouteFound', :method => 'noroute'},routes.route_request( "/"))
-    routes = Merb::RouteMatcher.new
-    assert_same_hash({:class => 'NoRouteFound', :method => 'noroute'},routes.route_request( "/dfnasfnafn"))
-    routes = Merb::RouteMatcher.new
-    assert_same_hash( {:class=>"Upload", :routes=>"234", :sweet=>"yup", :method=>"start"}, routes.route_request( "/these/234/are/yup"))
-    routes = Merb::RouteMatcher.new
-    assert_same_hash( {:class=>"Test", :a=>"12", :c=>"red", :id=>"12", :f=>"blue"}, routes.route_request( '/h/12/b/red/d/blue/g/12'))
+    assert_same_hash({:controller=>"lots",  :action=>"of", :id => "12"},routes.route_request( "/lots/of/12"))
   end  
   
-  def test_route_doesnt_match
-    routes = Merb::RouteMatcher.new
-    assert_same_hash({:class=>"NoRouteFound", :method=>"noroute"},routes.route_request( '/hdsfvsdfsdfdsf'))
-  end
-  
-  def test_regexes_included_in_compiled_statement
+  def test_catch_all_glob_route
     routes = Merb::RouteMatcher.new
-    routes.routes.each do |r|
-      assert Regexp.new(r[0]) =~ routes.compiled_statement
-    end  
-  end
-  
+    assert_same_hash({:controller=>"Test",  :action=>"glob", :rest => "hey/you/guys"},routes.route_request( "/bar/hey/you/guys"))
+  end  
+
 end