merb 0.0.4 → 0.0.5

data/examples/sample_app/script/merb_stop

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require 'fileutils'
+pids = IO.readlines(File.dirname(__FILE__)+"/../log/merb.pid").map{|p| p.to_i}
+
+pids.each do |pid|
+  puts "killing PID: #{pid}"
+  Process.kill(9, pid)
+end
+FileUtils.rm File.dirname(__FILE__)+"/../log/merb.pid"

data/examples/sample_app/script/new_migration

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'merb'
+
+TMPL = <<EOF
+class <%= class_name.snake_case.camel_case %> < ActiveRecord::Migration
+  def self.up
+  end
+
+  def self.down
+  end
+end
+EOF
+
+class_name = ARGV[0]
+highest_migration = Dir[Dir.pwd+'/dist/schema/migrations/*'].map{|f| File.basename(f) =~ /^(\d+)/; $1}.max
+filename = format("%03d_%s", (highest_migration.to_i+1), class_name.snake_case)
+
+File.open(Dir.pwd+"/dist/schema/migrations/#{filename}.rb", 'w+') do |file|
+  file.write Erubis::Eruby.new(TMPL).result(binding)
+end

data/lib/merb.rb

@@ -2,12 +2,15 @@ require 'rubygems'
 require 'mongrel'
 require 'fileutils'
 require 'erubis'
-require 'merb_config'
-
+require 'logger'
 
 module Merb
-  VERSION='0.0.4' unless defined?VERSION
+  VERSION='0.0.5' unless defined?VERSION
 end
 
+MERB_FRAMEWORK_ROOT = File.dirname(__FILE__)
+MERB_ROOT = Merb::Server.config[:merb_root] rescue Dir.pwd
+DIST_ROOT = Merb::Server.config[:dist_root] rescue Dir.pwd+'/dist'
+MERB_LOGGER =  Logger.new("#{MERB_ROOT}/log/merb.log")
 lib = File.join(File.dirname(__FILE__), 'merb')
-Dir.foreach(lib) {|fn| require File.join(lib, fn) if fn =~ /\.rb$/}
+Dir.entries(lib).sort.each {|fn| require File.join(lib, fn) if fn =~ /\.rb$/}

data/lib/merb/merb_controller.rb

@@ -10,7 +10,10 @@ module Merb
     
     attr_accessor :status
     
-    
+    # parses the http request into params, headers and cookies
+    # that you can use in your controller classes. Also handles
+    # file uploads by writing a tempfile and passing a reference 
+    # in params.
     def initialize(req, env, args, method=(env['REQUEST_METHOD']||"GET")) #:nodoc:
       env = MerbHash[env.to_hash]
       puts env.inspect if $DEBUG
@@ -57,31 +60,50 @@ module Merb
         qs.merge!(query_parse(@in.read))
       end
       @cookies, @params = @k.dup, qs.dup.merge(args)
+      MERB_LOGGER.info("Params: #{params.inspect}")
     end
 
+    # redirect to another url It can be like /foo/bar
+    # for redirecting within your same app. Or it can
+    # be a fully qualified url to another site.
     def redirect(url)
+      MERB_LOGGER.info("Redirecting to: #{url}")
       @status = 302
       @headers.merge!({'Location'=> url})
       return ''
     end
 
+    # pass in a path to a file and this will set the
+    # right headers and let mongrel do its thang and
+    # serve the static file directly.
     def send_file(file)
       headers['X-SENDFILE'] = file
       return
     end
 
+    # accessor for @params. Please use params and 
+    # never @params directly.
     def params
       @params
     end  
     
+    # accessor for @cookies. Please use cookies and 
+    # never @cookies directly.    
     def cookies
       @cookies
     end  
 
+    # accessor for @headers. Please use headers and 
+    # never @headers directly.
     def headers
       @headers
     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
+    # parses into:
+    # {:bar => 'nik', :post => {:title => 'heya', :body => 'whatever}}
     def query_parse(qs, d = '&;')
       m = proc {|_,o,n|o.update(n,&m)rescue([*o]<<n)}
       (qs||'').split(/[#{d}] */n).inject(MerbHash[]) { |h,p| 
@@ -91,34 +113,75 @@ module Merb
           }
     end
 
+    # does url escaping
     def escape(s)
       Mongrel::HttpRequest.escape(s)
     end
 
+    # does url unescaping
     def unescape(s)
       Mongrel::HttpRequest.unescape(s)
     end
  
-  
+    # escape text for javascript.
+    def escape_js(javascript)
+      (javascript || '').gsub('\\','\0\0').gsub(/\r\n|\n|\r/, "\\n").gsub(/["']/) { |m| "\\#{m}" }
+    end
+    alias :js :escape_js
+    
+    # shortcut to a template path based on name.
     def template_dir(loc)
       File.expand_path(Merb::Server.config[:merb_root] + "/dist/app/views/#{loc}")
     end  
     
+    # returns the current method name. Used for
+    # auto discovery of which template to render
+    # based on the action name.
     def current_method_name(depth=0)
       caller[depth] =~ /`(.*)'$/; $1
     end
 
+    # does a render with no layout. Also sets the
+    # content type header to text/javascript and
+    # escapes the template for javascript eval on
+    # the client
+    def render_js(template=current_method_name(1), b=binding)
+      headers['Content-Type'] = "text/javascript"
+      template = Erubis::Eruby.new(IO.read( template_dir(self.class.name.snake_case) + "/#{template}.merbjs" )) 
+      template.result(b)
+    end
     
+    # set the @layout. Use this right before a render to
+    # set the name of the layout to use minus the .rhtml
     def layout(l)
        @layout = l 
     end
     
+    def render_nothing(status)
+      @status = status
+      return ''
+    end
+    
+    # renders the action without wrapping it in a layout.
     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  
+    end 
+    
+    def partial(template)
+      template = Erubis::Eruby.new( IO.read( template_dir(self.class.name.snake_case) + "/_#{template}.rhtml" ) ) 
+      template.result(binding)
+    end 
     
+    # renders a template based on the current action name
+    # you can pass the name of a template if you want to
+    # render a template with a different name then then 
+    # current action name. Wraps the rendered template in
+    # the layout. Uses layout/application.rhtml unless
+    # there is a layout named after the current controller
+    # or @layout has been set to another value.
     def render(template=current_method_name(1), b=binding)
+      MERB_LOGGER.info("Rendering template: #{template_dir(template)}")
       name = self.class.name.snake_case
       template = Erubis::Eruby.new( IO.read( template_dir(name) + "/#{template}.rhtml" ) ) 
       layout_content = template.result(b)
@@ -132,12 +195,28 @@ module Merb
       else
         layout = @layout.to_s
       end
+      MERB_LOGGER.info("With Layout: #{template_dir('layout')}/#{layout}.rhtml")
       @layout_content = layout_content
       layout_tmpl = Erubis::Eruby.new( IO.read( template_dir('layout') + "/#{layout}.rhtml" ) )      
       layout_tmpl.result(b)
     end  
 
-    
   end  
   
+end
+
+class Noroutefound < Merb::Controller
+  # This is the class that handles requests that don't
+  # match any defined routes.
+
+  def method_missing(sym, *args, &blk)
+    @status = 404
+    "<html><body><h1>No Matching Route</h1></body></html>"    
+  end  
+
+  def to_s
+    @status = 404
+    "<html><body><h1>No Matching Route s</h1></body></html>"    
+  end
+
 end

data/lib/merb/merb_handler.rb

@@ -4,7 +4,7 @@ class MerbHandler < Mongrel::HttpHandler
   
   # take the name of a directory and use that as the doc root or public
   # directory of your site. This is set to the root of your merb app + '/public'
-  # by default. See merb_daemon.rb if you want to change this.
+  # by default.
   def initialize(dir, opts = {})
     @files = Mongrel::DirHandler.new(dir,false)
     @guard = Sync.new
@@ -29,6 +29,8 @@ class MerbHandler < Mongrel::HttpHandler
       return
     end
     
+    MERB_LOGGER.info("Request: PATH_INFO: #{request.params[Mongrel::Const::PATH_INFO]}")
+    
     # Rails style page caching. Check the public dir first for
     # .html pages and serve directly. Otherwise fall back to Merb 
     # routing and request dispatching. 
@@ -38,9 +40,12 @@ class MerbHandler < Mongrel::HttpHandler
 
     if get_or_head and @files.can_serve(path_info)
       # File exists as-is so serve it up
+      MERB_LOGGER.info("Serving static file: #{path_info}")
+      
       @files.process(request,response)
     elsif get_or_head and @files.can_serve(page_cached)
       # Possible cached page, serve it up
+      MERB_LOGGER.info("Serving static file: #{path_info}")
       request.params[Mongrel::Const::PATH_INFO] = page_cached
       @files.process(request,response)
     else
@@ -49,12 +54,13 @@ class MerbHandler < Mongrel::HttpHandler
         # 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
+        MERB_LOGGER.info("Routing to controller: #{controller.class} action: #{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))
+          output = 
+          if (controller && controller.kind_of?(Merb::Controller))
             if action
               controller.send(action)
             else
@@ -67,7 +73,8 @@ class MerbHandler < Mongrel::HttpHandler
       rescue Exception => e
         response.start(500) do |head,out|
           head["Content-Type"] = "text/html"
-          out << exception(e)
+          MERB_LOGGER.info(ex = exception(e))
+          out << ex
         end  
         return
       end   
@@ -89,12 +96,16 @@ class MerbHandler < Mongrel::HttpHandler
         end
       end
       
+      controller = nil
+      
       if sendfile
+        MERB_LOGGER.info("X-SENDFILE: #{sendfile}")
         # send X-SENDFILE header to mongrel
         response.send_status(File.size(sendfile))
         response.send_header
         response.send_file(sendfile)
       else
+        MERB_LOGGER.info("Response status: #{response.status}\n\n")
         # render response from successful controller
         response.send_status(output.length)
         response.send_header
@@ -107,17 +118,17 @@ class MerbHandler < Mongrel::HttpHandler
   # and use that in the merb routematcher to determine
   # which controller and method to run. 
   # returns a 2 element tuple of:
-  # [controller_object, method]
+  # [controller, action]
   def handle(request)
     path = request.params[Mongrel::Const::PATH_INFO].sub(/\/+/, '/')
     path = path[0..-2] if (path[-1] == ?/)
     route = Merb::RouteMatcher.new.route_request(path)
-    puts route.inspect if $DEBUG
     if route
-      [ instantiate_controller(route[:controller], request.body, request.params, 
-                               route.dup.delete_if{|k,v| [:controller, :action].include? k}), 
-                               route[:action]]
+      MERB_LOGGER.info("No Matching Route!") if route[:controller] == 'Noroutefound'
+      [ instantiate_controller(route[:controller], request.body, request.params, route), 
+        route[:action] ]
     else  
+      MERB_LOGGER.info("No Matching Route!")
       ["<html><body>Error: no route matches!</body></html>", nil]
     end
   end

data/lib/merb/merb_router.rb

@@ -13,8 +13,10 @@ module Merb
   class RouteMatcher
     
     attr_accessor :sections
-    @@section_regexp = /(?::([a-z*]+))/.freeze
+    @@section_regexp = /(?::([a-z*_]+))/.freeze
     
+    # setup the router and yield it out to
+    # add routes to it. Then compile all routes
     def self.prepare
       @@routes = Array.new
       @@compiled_statement = String.new
@@ -22,22 +24,31 @@ module Merb
       compile_router
     end  
     
+    # init @sections for route segment recognition
     def initialize
       @sections = Hash.new
     end  
     
+    # all defined routes in their raw form.
     def routes
       @@routes
     end  
     
+    # the final compiled lambda that gets used
+    # as the body of the route_request method.
     def compiled_statement
       @@compiled_statement
     end
   
+    # add a route to be compiled
     def self.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.
     def self.compile_router
       router_lambda = @@routes.inject("lambda{|path| \n  case path\n") { |m,r|
         m << compile(r)
@@ -46,6 +57,12 @@ module Merb
       define_method(:route_request, &eval(router_lambda))
     end  
     
+    # compile each individual route into a when /.../
+    # component of the case statement. Takes /:sections
+    # if the route def that start with : and turns them
+    # into placeholders for whatever urls match against
+    # the route in question. Special case for the default
+    # /:controller/:action/:id route.
     def self.compile(route)
       raise ArgumentError unless String === route[0]
       if route[0] == '/:controller/:action/:id'

data/lib/merb/merb_utils.rb

@@ -1,14 +1,19 @@
 class String
+  
+  # reloads controller classes on each request if
+  # :allow_reloading is set to true in the config
+  # file or command line options.
   def import
     Merb::Server.config[:allow_reloading] ? load(  self.snake_case  + '.rb' ) : require(  self.snake_case )
   end
   
+  # "FooBar".snake_case #=> "foo_bar"
   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
 
-
+  # "foo_bar".camel_case #=> "FooBar"
   def camel_case
     return self if self =~ %r/[A-Z]/ and self !~ %r/_/
     words = self.strip.split %r/\s*_+\s*/
@@ -19,9 +24,13 @@ class String
 end
 
 class Symbol
+  
+  # faster Symbol#to_s to speed up routing.
   def to_s
     @str_rep || (@str_rep = id2name.freeze)
   end
+  
+  # ["foo", "bar"].map &:reverse #=> ['oof', 'rab']
   def to_proc
      Proc.new{|*args| args.shift.__send__(self, *args)}
    end
@@ -40,6 +49,7 @@ class Hash
   end
 end  
 
+# like HashWithIndifferentAccess from ActiveSupport.
 class MerbHash < Hash
   def initialize(constructor = {})
     if constructor.is_a?(Hash)

data/lib/merb_tasks.rb

@@ -0,0 +1,7 @@
+$VERBOSE = nil
+
+# Load Merb rakefile extensions
+Dir["#{File.dirname(__FILE__)}/tasks/**/*.rake"].each { |ext| load ext }
+
+# Load any custom rakefile extensions
+Dir["./lib/tasks/**/*.rake"].sort.each { |ext| load ext }

data/lib/tasks/db.rake

@@ -0,0 +1,53 @@
+taMERB_ROOT = Dir.pwd
+
+desc "Setup the Merb Environment by requiring merb and loading your merb_init.rb"
+task :merb_env do
+  require 'rubygems'
+  require 'merb'
+  load MERB_ROOT+'/dist/conf/merb_init.rb'
+end
+
+namespace :db do
+  desc "Migrate the database through scripts in dist/schema/migrate. Target specific version with VERSION=x"
+  task :migrate => :merb_env do
+    ActiveRecord::Migrator.migrate("dist/schema/migrations/", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+    Rake::Task["db:schema:dump"].invoke
+  end
+
+  namespace :schema do
+    desc "Create a db/schema.rb file that can be portably used against any DB supported by AR"
+    task :dump => :merb_env do
+      require 'active_record/schema_dumper'
+      File.open(ENV['SCHEMA'] || "dist/schema/schema.rb", "w") do |file|
+        ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
+      end
+    end
+
+    desc "Load a schema.rb file into the database"
+    task :load => :merb_env do
+      file = ENV['SCHEMA'] || "dist/schema/schema.rb"
+      load(file)
+    end
+  end
+
+  namespace :sessions do
+    desc "Creates a sessions table for use with CGI::Session::ActiveRecordStore"
+    task :create => :merb_env do
+      raise "Task unavailable to this database (no migration support)" unless ActiveRecord::Base.connection.supports_migrations?
+      require 'rails_generator'
+      require 'rails_generator/scripts/generate'
+      Rails::Generator::Scripts::Generate.new.run(["session_migration", ENV["MIGRATION"] || "AddSessions"])
+    end
+
+    desc "Clear the sessions table"
+    task :clear => :merb_env do
+      session_table = 'session'
+      session_table = Inflector.pluralize(session_table) if ActiveRecord::Base.pluralize_table_names
+      ActiveRecord::Base.connection.execute "DELETE FROM #{session_table}"
+    end
+  end
+end
+
+def session_table_name
+  ActiveRecord::Base.pluralize_table_names ? :sessions : :session
+end