merb 0.2.0 → 0.3.0

data/README

@@ -1,10 +1,9 @@
-<pre>
+
 Copyright (c) 2006 Ezra Zygmuntowicz
 
-Merb. Mongrel+Erb
+Merb.
 
-Little bitty lightweight ruby app server. For when you really need performance
-for simple dynamic pages.
+Lightweight MVC Ruby app server. For high performance dynamic pages.
 
 ** Dependencies **
 mongrel
@@ -33,6 +32,7 @@ params into params and the cookies into cookies when it instantiates your
 controller class.
 
 *RouteMatcher and route compiler* 
+
 Reads your route definition and compiles
 a method on the fly that will match the request path against each route and do the right thing.
 
@@ -42,93 +42,52 @@ note the r.resource :posts macro. That makes it possible to use a restfull crud
 
 Merb::RouteMatcher.prepare do |r|
   r.resources :posts
-  r.add '/:controller/:action/:id'
+  r.default_routes
   r.add '/', :controller => 'files', :action => 'index'
 end
 
-Will be compiled and defined as a method with this lambda as the body:
-
-lambda{|path| 
-  case path
-  when Regexp.new('/posts/([^/,?]+)[;]edit')
-    @sections[:id] = $1
-    return {:rest=>true, :controller=>"posts", :allowed=>{:get=>"edit"}}.update(@sections)
-  when Regexp.new('/posts/new[;]([^/,?]+)')
-    @sections[:action] = $1
-    return {:rest=>true, :controller=>"posts", :allowed=>{:post=>"new", :get=>"new", :delete=>"new", :put=>"new"}}.update(@sections)
-  when Regexp.new('/posts/new')
-    return {:rest=>true, :controller=>"posts", :allowed=>{:get=>"new"}}.update(@sections)
-  when Regexp.new('/posts/([^/,?]+)\.([^/,?]+)')
-    @sections[:id] = $1
-    @sections[:format] = $2
-    return {:rest=>true, :controller=>"posts", :allowed=>{:get=>"show", :delete=>"destroy", :put=>"update"}}.update(@sections)
-  when Regexp.new('/posts\.([^/,?]+)')
-    @sections[:format] = $1
-    return {:rest=>true, :controller=>"posts", :allowed=>{:post=>"create", :get=>"index"}}.update(@sections)
-  when Regexp.new('/posts/([^/,?]+)')
-    @sections[:id] = $1
-    return {:rest=>true, :controller=>"posts", :allowed=>{:get=>"show", :delete=>"destroy", :put=>"update"}}.update(@sections)
-  when Regexp.new('/posts/?')
-    return {:rest=>true, :controller=>"posts", :allowed=>{:post=>"create", :get=>"index"}}.update(@sections)
-  when /\A\/([^\/;.,?]+)(?:\/?\Z|\/([^\/;.,?]+)\/?)(?:\/?\Z|\/([^\/;.,?]+)\/?)\Z/
-      @sections[:controller] = $1
-      @sections[:action] = $2 || 'index'
-      @sections[:id] = $3 if $3
-      return @sections
-  when Regexp.new('/')
-    return {:controller=>"files", :action=>"index"}.update(@sections)
-  else
-    return {:controller=>'Noroutefound', :action=>'noroute'}
-  end
-}
+The r.default_routes routes adds the standard routes:
 
+/controller/action/id.xml
+/controller/action/id
+/controller/action.xml
+/controller/action
+/controller.xml  # index action
+/controller      # index action
 
-*Restful Controller*
 
-restful controllers use a different dispatch system based on the request method verbs.
 
-class Posts < Merb::Controller
-  # GET /posts
-  # GET /posts.xml
-  def index
-  end
-
-  # GET /posts/1
-  # GET /posts/1.xml
-  def show
-  end
-
-  # GET /posts/new
-  def new
-  end
-
-  # GET /posts/1;edit
-  def edit
-  end
-
-  # POST /posts
-  # POST /posts.xml
-  def create
-  end
-
-  # PUT /posts/1
-  # PUT /posts/1.xml
-  def update
-  end
-
-  # DELETE /posts/1
-  # DELETE /posts/1.xml
-  def destroy
-  end
-end
-
-
-*Simple Controllers*
-classes with built in render method and template handling
+*Controllers*
+Classes with built in render method and template handling
 with instance vars available in the views automatically. Merb also supports 
 layouts. It will look for a layout named after your controller class first and
 then fall back to application.herb if no layout exists named after your controller.
-You can use render_no_layout or do render :layout => :none
+You can use render :layout => :none.
+
+Merb does not automatically render for you in your controller actions, you have
+to call render yourself. I consider this a big advantage over the way rails does 
+it for a few reasons. The main reason is that in rails you can only render once 
+per action, so it knows if you haven’t rendered it shoudl auto render. Merb on 
+the other hand, returns to the browser whatever the return value of your 
+controller’s action method is. This opens up more possibilities imho because
+ now you can return any string from your action and that will be sent down 
+the pipe. So Merb’s render method just returns a string and needs to be the 
+last thing you call in your action. You can render multiple times and capture 
+the results into @ivars and then render a master template with many embeded 
+templates. Also if you return a handle on a File or IO object from your action 
+then merb will hand that over to mongrel to be streamed out to the client. And 
+if you return a Proc object from your action, it will be called and the 
+return value sent to the client.
+
+That last point has some cool connotations if you think about it. Merb does 
+have a mutex lock around the call to your controller’s action anywhere that
+ you can call AR objects. Merb’s lock is way smaller then rails giant lock 
+though and allows for many more concurrent requests to be handled by one 
+process. By returning a Proc object from your action, you allow merb to 
+release the lock and the proc is called in multi threaded way. This allows 
+for all kinds of cool streaming and ‘futures’ where you return the proc and 
+release the mutex. It’s basically like handing over the proc to mongrel and 
+mongrel handles calling it in a thread safe manner.
 
 
 class Test < Merb::Controller 
@@ -141,6 +100,7 @@ end
 
 You can also render partials like so:
 <%= partial(:comments) %>
+
 This assumes a _comments.rhtml file in the same view dir as the current 
 controller/view
 
@@ -179,14 +139,56 @@ $('comments').update('<%=js partial(:posts) %>');
 </ul>	
 
 
+*Restful Controllers*
+
+restful controllers use a different dispatch system based on the request method verbs. Merb
+supports multi return values based on the accept header via respond_to
+
+class Posts < Merb::Controller
+  # GET /posts
+  # GET /posts.xml
+  def index
+    @posts = Post.find :all
+    respond_to {|format|
+      format.html { render }
+      format.js   { render :js => 'index' }
+      format.xml  { render :xml => @posts.to_xml }
+    }
+  end
+
+  # GET /posts/1
+  # GET /posts/1.xml
+  def show
+  end
+
+  # GET /posts/new
+  def new
+  end
+
+  # GET /posts/1;edit
+  def edit
+  end
+
+  # POST /posts
+  # POST /posts.xml
+  def create
+  end
+
+  # PUT /posts/1
+  # PUT /posts/1.xml
+  def update
+  end
+
+  # DELETE /posts/1
+  # DELETE /posts/1.xml
+  def destroy
+  end
+end
+
+
 *Controllers have powerful before and after filters*
 
-Use the before method in your controllers. before accepts either a symbol 
-or a Proc/lambda object. If you give it a symbol it will call a method with
-the same name as the symbol. If you give it a proc that takes one argument 
-it will call the proc with the current controller as that argument. You can 
-use :only and :exclude as options to your filters to exclude or include actionsfrom certain filters. :only and :exclude take :symbols or [:sym, :sam]
-array of symbols.
+Use the before method in your controllers. before accepts either a symbol, string or a Proc/lambda object. If you give it a symbol it will call a method with the same name as the symbol. If you give it a proc that takes one argument it will call the proc with the current controller as that argument. You can use :only and :exclude as options to your filters to exclude or include actionsfrom certain filters. :only and :exclude take :symbols or [:sym, :sam] array of symbols.
 
 class Foo < Merb::Controller
  
@@ -224,21 +226,23 @@ throw :halt, Proc.new{ |c| c.redirect "/foo" }
 
 # halts the chain and returns whatever is in the string
 
-throw :halt, "<h1>You don't have permissions IDIOT!</h1>"
+throw :halt, "<h1>You don't have permissions dude!</h1>"
 
 or even render templates:
 
 throw :halt, render 'foo'
 throw :halt, partial 'foo'
 
-After filters only accept a Proc and call that proc with the controller:
+After filters accept a symbol, string or   Proc and call that proc with the controller:
 
 after Proc.new {|c| Tidy.new(c.body) }, :only => :index
 
-Sessions are available when you start merb with the sql_session set to true or the memory_session set to true. See generated app for migration too add session table.
-
-Helpers: dist/app/helpers/global_helper.rb will be available to all of your views. Helpers named afdter your controller plus _helper.rb will be included in the views for that controller only.
+Sessions are available when you start merb with the sql_session set to true or the 
+memory_session set to true. See generated app for migration too add session table.
 
+Helpers: dist/app/helpers/global_helper.rb will be available to all of your views.
+ Helpers named after your controller plus _helper.rb will be included in the views
+ for that controller only.
 
 *The merb server*
 right now you add your routes in
@@ -264,7 +268,7 @@ $merb -i
 *File uploads* 
 This is one of the things that Merb was written for. Rails doesn't allow 
 multiple concurrent file uploads at once without blocking an entire rails backend for each file upload. Merb allows multiple file uploads at once.
-progress bar. When a file is uploaded with Merb, it gets put in a Tempfile. So 
+ When a file is uploaded with Merb, it gets put in a Tempfile. So 
 you just want to copy it to the right place on the filesystem.
 
 def upload
@@ -275,6 +279,13 @@ def upload
   render
 end
 
+A file upload will have a hash of params like this:
+{ 
+:filename => File.basename(filename),  
+:content_type => content_type,  
+:tempfile => <Tempfile>, 
+:size => File.size(body) 
+}
 
 *Merb app layout* 
 
@@ -303,5 +314,4 @@ merb_app:
     lib
     public
     plugins
-    schema
-</pre>
+    schema

data/Rakefile

@@ -15,7 +15,7 @@ include FileUtils
 
 
 NAME = "merb"
-VERS = "0.2.0"
+VERS = "0.3.0"
 CLEAN.include ['**/.*.sw?', '*.gem', '.config']
 
 setup_clean [ "pkg", "lib/*.bundle", "*.gem", 
@@ -91,8 +91,8 @@ end
 desc "rdoc to rubyforge"
 task :doc_rforge do
   sh %{rake doc}
-  sh %{sudo chmod -R 755 doc/rdoc}
-  sh %{scp -r -p doc/rdoc/* ezmobius@rubyforge.org:/var/www/gforge-projects/merb}
+  sh %{sudo chmod -R 755 doc}
+  sh %{scp -r -p doc/* ezmobius@rubyforge.org:/var/www/gforge-projects/merb}
 end
 
 
@@ -132,8 +132,7 @@ end
 
 desc 'Run all tests, specs and finish with rcov'
 task :aok do
-  sh %{rake rcov}
-  sh %{rake spec}
+  sh %{rake specs}
 end
 
 desc "Run all specs"

data/examples/skeleton/dist/conf/router.rb

@@ -11,9 +11,12 @@
 
 puts "Compiling routes.."
 Merb::RouteMatcher.prepare do |r|
+  # restfull routes
+  # r.resources :posts
+
   # default route, usually you don't want to change this
-  r.add '/:controller/:action/:id' 
+  r.default_routes
   
   # change this for your home page to be avaiable at /
-  r.add '/', :controller => 'default', :action =>'index'
+  #r.add '/', :controller => 'whatever', :action =>'index'
 end

data/examples/skeleton/dist/schema/migrations/001_add_sessions_table.rb

@@ -1,7 +1,6 @@
 class AddSessionsTable < ActiveRecord::Migration
   def self.up
     create_table :sessions, :force => true do |t|
-        t.column :id,          :integer, :null => false
         t.column :session_id,      :string,  :limit => 32
         t.column :created_at,  :datetime
         t.column :data,       :text

data/lib/merb.rb

@@ -12,7 +12,7 @@ end
 
 
 module Merb
-  VERSION='0.2.0' unless defined?VERSION
+  VERSION='0.3.0' unless defined?VERSION
   class Server
     class << self
       def config
@@ -69,10 +69,17 @@ MERB_LOGGER.level = case (Merb::Server.log_level.downcase rescue '')
                       Logger::INFO
                     end  
 
-                      
+module Mongrel::Const
+  HTTP_COOKIE   =  'HTTP_COOKIE'.freeze
+  QUERY_STRING  =  'QUERY_STRING'.freeze
+  CONTENT_TYPE_TEXT_HTML_HASH = {'Content-Type' =>'text/html'}
+  APPLICATION_JSON = 'application/json'.freeze 
+  TEXT_JSON        = 'text/x-json'.freeze
+  UPCASE_CONTENT_TYPE = 'CONTENT_TYPE'.freeze
+end  
          
 lib = File.join(__DIR__, 'merb')
-Dir.entries(lib).sort.each {|fn| require File.join(lib, fn) if fn =~ /\.rb$/}
+Dir.entries(lib).sort.select{|f| f !~ /merb\/session\// }.each {|fn| require File.join(lib, fn) if fn =~ /\.rb$/}
 
 require File.join(__DIR__, 'merb/vendor/paginator/paginator')
 

data/lib/merb/core_ext.rb

@@ -1,6 +1,7 @@
 corelib = __DIR__+'/merb/core_ext'
 
-%w[ merb_class
+%w[ merb_inflector
+    merb_class
     merb_kernel
     merb_object
     merb_enumerable
@@ -9,4 +10,5 @@ corelib = __DIR__+'/merb/core_ext'
     merb_hash
     merb_numeric
     merb_symbol
+    
   ].each {|fn| require File.join(corelib, fn)}

data/lib/merb/core_ext/merb_class.rb

@@ -1,106 +1,140 @@
-class Class # :nodoc:
-  
-  def cattr_reader(*syms)
-    syms.flatten.each do |sym|
-      class_eval(<<-EOS, __FILE__, __LINE__)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
+# Retain for backward compatibility.  Methods are now included in Class.
+module ClassInheritableAttributes # :nodoc:
+end
 
+# Allows attributes to be shared within an inheritance hierarchy, but where each descendant gets a copy of
+# their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
+# to, for example, an array without those additions being shared with either their parent, siblings, or
+# children, which is unlike the regular class-level attributes that are shared across the entire hierarchy.
+class Class # :nodoc:
+  def class_inheritable_reader(*syms)
+    syms.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval <<-EOS
         def self.#{sym}
-          @@#{sym}
+          read_inheritable_attribute(:#{sym})
         end
 
         def #{sym}
-          @@#{sym}
+          self.class.#{sym}
         end
       EOS
     end
   end
 
-  def cattr_writer(*syms)
-    syms.flatten.each do |sym|
-      class_eval(<<-EOS, __FILE__, __LINE__)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-
+  def class_inheritable_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.each do |sym|
+      class_eval <<-EOS
         def self.#{sym}=(obj)
-          @@#{sym} = obj
+          write_inheritable_attribute(:#{sym}, obj)
         end
 
+        #{"
         def #{sym}=(obj)
-          @@#{sym} = obj
+          self.class.#{sym} = obj
         end
+        " unless options[:instance_writer] == false }
       EOS
     end
   end
 
-  def cattr_accessor(*syms)
-    cattr_reader(*syms)
-    cattr_writer(*syms)
-  end
-  
-  def shared_reader(*syms)
+  def class_inheritable_array_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
     syms.each do |sym|
       class_eval <<-EOS
-        def self.#{sym}
-          read_shared_attribute(:#{sym})
+        def self.#{sym}=(obj)
+          write_inheritable_array(:#{sym}, obj)
         end
 
-        def #{sym}
-          self.class.#{sym}
+        #{"
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
         end
+        " unless options[:instance_writer] == false }
       EOS
     end
   end
 
-  def shared_writer(*syms)
+  def class_inheritable_hash_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
     syms.each do |sym|
       class_eval <<-EOS
         def self.#{sym}=(obj)
-          write_shared_attribute(:#{sym}, obj)
+          write_inheritable_hash(:#{sym}, obj)
         end
 
+        #{"
         def #{sym}=(obj)
           self.class.#{sym} = obj
         end
+        " unless options[:instance_writer] == false }
       EOS
     end
   end
 
-  def shared_accessor(*syms)
-    shared_reader(*syms)
-    shared_writer(*syms)
+  def class_inheritable_accessor(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms)
+  end
+
+  def class_inheritable_array(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_array_writer(*syms)
+  end
+
+  def class_inheritable_hash(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_hash_writer(*syms)
   end
 
-  def shared_attributes
-    @shared_attributes ||= {}
+  def inheritable_attributes
+    @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES
   end
   
-  def write_shared_attribute(key, value)
-    shared_attributes[key] = value
+  def write_inheritable_attribute(key, value)
+    if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+      @inheritable_attributes = {}
+    end
+    inheritable_attributes[key] = value
+  end
+  
+  def write_inheritable_array(key, elements)
+    write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
   end
 
-  def read_shared_attribute(key)
-    shared_attributes[key]
+  def write_inheritable_hash(key, hash)
+    write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
+  end
+
+  def read_inheritable_attribute(key)
+    inheritable_attributes[key]
   end
   
-  def reset_shared_attributes
-    shared_attributes.clear
+  def reset_inheritable_attributes
+    @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
   end
 
-  private 
-    def inherited_with_shared_attributes(child)
-      inherited_without_shared_attributes(child) if respond_to?(:inherited_without_shared_attributes)
+  private
+    # Prevent this constant from being created multiple times
+    EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze unless const_defined?(:EMPTY_INHERITABLE_ATTRIBUTES)
+
+    def inherited_with_inheritable_attributes(child)
+      inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
       
-      new_shared_attributes = shared_attributes.inject({}) do |memo, (key, value)|
-        memo.update(key => (value.dup rescue value))
+      if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
+        new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
+      else
+        new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)|
+          memo.update(key => (value.dup rescue value))
+        end
       end
       
-      child.instance_variable_set('@shared_attributes', new_shared_attributes)
+      child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
     end
 
-    alias inherited_without_shared_attributes inherited
-    alias inherited inherited_with_shared_attributes
-end
+    alias inherited_without_inheritable_attributes inherited
+    alias inherited inherited_with_inheritable_attributes
+end