merb 0.3.1 → 0.3.3

data/README

@@ -8,7 +8,7 @@ Lightweight MVC Ruby app server. For high performance dynamic pages.
 ** Dependencies **
 mongrel
 erubis
-json or fjson
+json
 mime-types
 archive-tar-minitar
 rspec

data/Rakefile

@@ -15,7 +15,7 @@ include FileUtils
 
 
 NAME = "merb"
-VERS = "0.3.1"
+VERS = "0.3.3"
 CLEAN.include ['**/.*.sw?', '*.gem', '.config']
 
 setup_clean [ "pkg", "lib/*.bundle", "*.gem", 
@@ -29,13 +29,6 @@ task :merb => [:clean, :rdoc, :package]
 task :doc => [:rdoc]
 
 
-#Rake::RDocTask.new do |rdoc|
-#  rdoc.rdoc_dir = 'doc/rdoc'
-#  rdoc.options += RDOC_OPTS
-#  rdoc.main = "README"
-#  rdoc.title = "Merb Documentation"
-#  rdoc.rdoc_files.add ['README', 'LICENSE', 'TODO', 'lib/**/*.rb']
-#end
 Rake::RDocTask.new do |rdoc|
      files =['README', 'LICENSE', 'TODO', 'lib/**/*.rb']
      rdoc.rdoc_files.add(files)
@@ -66,6 +59,9 @@ spec = Gem::Specification.new do |s|
   s.add_dependency('mongrel')
   s.add_dependency('erubis')
   s.add_dependency('json')
+  s.add_dependency('mime-types')
+  s.add_dependency('xml-simple')
+  s.add_dependency('archive-tar-minitar') 
   s.required_ruby_version = '>= 1.8.4'
 
   s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{bin,test,lib,examples}/**/*") 
@@ -132,7 +128,7 @@ end
 
 desc 'Run all tests, specs and finish with rcov'
 task :aok do
-  sh %{rake specs}
+  sh %{rake specs;rake rcov}
 end
 
 desc "Run all specs"
@@ -144,11 +140,25 @@ end
 
 desc "RCov"
 Spec::Rake::SpecTask.new('rcov') do |t|
+  t.spec_opts = ["--format", "specdoc"]
   t.spec_files = FileList['specs/**/*_spec.rb']
   t.libs = ['lib', 'server/lib' ]
   t.rcov = true
 end
 
+STATS_DIRECTORIES = [
+  %w(Code               lib/),
+  %w(Unit\ tests        specs),
+].collect { |name, dir| [ name, "./#{dir}" ] }.select { |name, dir| File.directory?(dir) }
+
+desc "Report code statistics (KLOCs, etc) from the application"
+task :stats do
+  require __DIR__ + '/tools/code_statistics'
+  #require 'extra/stats'
+  verbose = true
+  CodeStatistics.new(*STATS_DIRECTORIES).to_s
+end
+
 ##############################################################################
 # SVN
 ##############################################################################

data/TODO

@@ -1,16 +1,3 @@
 [TODO]
-* Irb Console **DONE**
-* Migrations **DONE**
-* Helpers
-* config file **DONE**
-* session
-  ** AR ** DONE **
-  ** DRb
-* Rails integration
-* Text backend?
-* plugins support(rails plugins too?)
-* Layouts **DONE**
-* auto template_dir **DONE**
-* before/after filters **DONE**
-* merbjs **DONE**
-* testing
+* more specs for Template engines and Rendering
+* 

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

@@ -10,7 +10,7 @@
 
 
 puts "Compiling routes.."
-Merb::RouteMatcher.prepare do |r|
+Merb::Router.prepare do |r|
   # restfull routes
   # r.resources :posts
 
@@ -19,4 +19,4 @@ Merb::RouteMatcher.prepare do |r|
   
   # change this for your home page to be avaiable at /
   #r.add '/', :controller => 'whatever', :action =>'index'
-end
+end

data/lib/merb.rb

@@ -11,16 +11,11 @@ end
 require 'fileutils'
 require 'erubis'
 require 'logger'
-
-begin
-  require 'fjson'
-rescue LoadError
-  require 'json'
-end
+require 'json'
 
 
 module Merb
-  VERSION='0.3.1' unless defined?VERSION
+  VERSION='0.3.3' unless defined?VERSION
   class Server
     class << self
       def config
@@ -56,6 +51,7 @@ MERB_FRAMEWORK_ROOT = __DIR__
 MERB_ROOT = Merb::Server.merb_root || Dir.pwd
 DIST_ROOT = Merb::Server.dist_root || Dir.pwd+'/dist'
 MERB_ENV  = Merb::Server.config[:environment]
+MERB_VIEW_ROOT = MERB_ROOT / "dist/app/views"
 
 logpath = $TESTING ? "/tmp/merb_test.log" : "#{MERB_ROOT}/log/merb.#{Merb::Server.port}.log"
 MERB_LOGGER = Logger.new(logpath)
@@ -78,10 +74,12 @@ MERB_LOGGER.level = case (Merb::Server.log_level.downcase rescue '')
                     end  
 
 module Mongrel::Const
-  HTTP_COOKIE   =  'HTTP_COOKIE'.freeze
-  QUERY_STRING  =  'QUERY_STRING'.freeze
-  APPLICATION_JSON = 'application/json'.freeze 
-  TEXT_JSON        = 'text/x-json'.freeze
+  HTTP_COOKIE         = 'HTTP_COOKIE'.freeze
+  QUERY_STRING        = 'QUERY_STRING'.freeze
+  APPLICATION_JSON    = 'application/json'.freeze 
+  TEXT_JSON           = 'text/x-json'.freeze
+  APPLICATION_XML     = 'application/xml'.freeze 
+  TEXT_XML            = 'text/xml'.freeze  
   UPCASE_CONTENT_TYPE = 'CONTENT_TYPE'.freeze
 end  
          

data/lib/merb/core_ext.rb

@@ -10,5 +10,4 @@ corelib = __DIR__+'/merb/core_ext'
     merb_hash
     merb_numeric
     merb_symbol
-    
   ].each {|fn| require File.join(corelib, fn)}

data/lib/merb/core_ext/merb_hash.rb

@@ -1,8 +1,77 @@
 class Hash
+
+  class << self
+    def from_xml(xml)
+      # TODO: Refactor this into something much cleaner that doesn't rely on XmlSimple
+      undasherize_keys(typecast_xml_value(XmlSimple.xml_in(xml,
+        'forcearray'   => false,
+        'forcecontent' => true,
+        'keeproot'     => true,
+        'contentkey'   => '__content__')
+      ))            
+    end
+
+    private
+      def typecast_xml_value(value)
+        case value.class.to_s
+          when "Hash"
+            if value.has_key?("__content__")
+              content = translate_xml_entities(value["__content__"])
+              case value["type"]
+                when "integer"  then content.to_i
+                when "boolean"  then content.strip == "true"
+                when "datetime" then ::Time.parse(content).utc
+                when "date"     then ::Date.parse(content)
+                else                 content
+              end
+            else
+              (value.blank? || value['type'] || value['nil'] == 'true') ? nil : value.inject({}) do |h,(k,v)|
+                h[k] = typecast_xml_value(v)
+                h
+              end
+            end
+          when "Array"
+            value.map! { |i| typecast_xml_value(i) }
+            case value.length
+              when 0 then nil
+              when 1 then value.first
+              else value
+            end
+          when "String"
+            value
+          else
+            raise "can't typecast #{value.inspect}"
+        end
+      end
+    
+      def translate_xml_entities(value)
+        value.gsub(/&lt;/,   "<").
+              gsub(/&gt;/,   ">").
+              gsub(/&quot;/, '"').
+              gsub(/&apos;/, "'").
+              gsub(/&amp;/,  "&")
+      end
+    
+      def undasherize_keys(params)
+        case params.class.to_s
+        when "Hash"
+          params.inject({}) do |h,(k,v)|
+            h[k.to_s.tr("-", "_")] = undasherize_keys(v)
+            h
+          end
+        when "Array"
+          params.map { |v| undasherize_keys(v) }
+        else
+          params
+        end
+     end
+  end
+  
+    
   def with_indifferent_access
     MerbHash.new(self)
   end
-  def to_params()
+  def to_params
     result = ''
     stack = []
 

data/lib/merb/core_ext/merb_symbol.rb

@@ -1,10 +1,4 @@
-class Symbol
-  
-  # faster Symbol#to_s to speed up routing.
-  def to_s
-    @str_rep ||= id2name.freeze
-  end
-  
+class Symbol  
   # ["foo", "bar"].map &:reverse #=> ['oof', 'rab']
   def to_proc
      Proc.new{|*args| args.shift.__send__(self, *args)}

data/lib/merb/merb_controller.rb

@@ -21,8 +21,8 @@ module Merb
     self._layout = :application
     self._session_id_key = :_session_id
     self._template_extensions = { }
-    self._template_root = File.expand_path(MERB_ROOT / "dist/app/views")
-    self._layout_root   = File.expand_path(MERB_ROOT / "dist/app/views/layout")
+    self._template_root = File.expand_path(MERB_VIEW_ROOT)
+    self._layout_root   = File.expand_path(MERB_VIEW_ROOT / "layout")
     
     include Merb::ControllerMixin
     include Merb::RenderMixin
@@ -51,6 +51,8 @@ module Merb
           json = JSON.parse(request.read || "") || {}
           json = MerbHash.new(json) if json.is_a? Hash
           querystring.update(json)
+        elsif [Mongrel::Const::APPLICATION_XML, Mongrel::Const::TEXT_XML].include?(@env[Mongrel::Const::UPCASE_CONTENT_TYPE])
+          querystring.update(Hash.from_xml(request.read).with_indifferent_access)
         else
           querystring.update(query_parse(request.read))
         end  
@@ -64,7 +66,7 @@ module Merb
       if @params.key?(:_method) && allow.include?(@method)
         @method = @params.delete(:_method).downcase.intern 
       end
-      @request = Request.new(@env, @method)
+      @request = Request.new(@env, @method, request)
       
       MERB_LOGGER.info("Params: #{params.inspect}\nCookies: #{cookies.inspect}")
     end
@@ -178,12 +180,14 @@ module Merb
         else
           ok = true
         end    
-        case filter
-          when Symbol, String
-           send(filter) if ok
-          when Proc
-           filter.call(self) if ok
-        end 
+        if ok
+          case filter
+            when Symbol, String
+             send(filter)
+            when Proc
+             filter.call(self)
+          end
+        end   
       end
       return :filter_chain_completed
     end 

data/lib/merb/merb_dispatcher.rb

@@ -49,7 +49,7 @@ module Merb
       def route_path(path)
         path = path.sub(/\/+/, '/').sub(/\?.*$/, '')
         path = path[0..-2] if (path[-1] == ?/) && path.size > 1
-        Merb::RouteMatcher.route_request(path)
+        Merb::Router.match(path)
       end
       
       # take a controller class name string and reload or require

data/lib/merb/merb_mailer.rb

@@ -45,11 +45,7 @@ module Merb
   end
 end
 =begin
-m = Merb::Mailer.new :to => 'foo@bar.com',
-                     :from => 'bar@foo.com',
-                     :subject => 'Welcome to whatever!',
-                     :body => partial(:sometemplate)
-m.deliver!                     
+
 
 Merb::Mailer.config = {
   :host=>'smtp.yourserver.com',
@@ -58,4 +54,10 @@ Merb::Mailer.config = {
   :pass=>'pass',
   :auth=>:plain # :plain, :login, or :cram_md5, default :plain
 }
+m = Merb::Mailer.new :to => 'foo@bar.com',
+                     :from => 'bar@foo.com',
+                     :subject => 'Welcome to whatever!',
+                     :body => partial(:sometemplate)
+m.deliver!                     
+
 =end

data/lib/merb/merb_request.rb

@@ -2,11 +2,17 @@ module Merb
 
   class Request
     attr_accessor :env
-    def initialize(env, method)
+    def initialize(env, method, request)
       @env = env
       @method = method
+      @request = request
     end
     
+    def raw_post
+      @request.rewind
+      @request.read
+    end  
+    
     # returns true if the request is an ajax request.
     def xml_http_request?
       not /XMLHttpRequest/i.match(@env['HTTP_X_REQUESTED_WITH']).nil?
@@ -148,9 +154,7 @@ module Merb
     
     # create predicate methods for querying the REQUEST_METHOD
     [:get, :post, :put, :delete, :head].each do |m|
-      eval %{
-        def #{m}?; method == :#{m}; end
-      }
+      define_method("#{m}?") { method == m.to_sym }
     end
   
   end

data/lib/merb/merb_router.rb

@@ -1,97 +1,248 @@
 module Merb
 
-  # Merb::RouteMatcher is the request routing mapper for the merb framework.
-  # 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. This route maps
-  # the default /controller/action and /controller/action/id urls:
-  # r.add '/:class/:method/:id'
-  class RouteMatcher
+  class Router
     
-    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
-      @@compiled_regexen = Array.new
-      yield self
-      compile_router
-    end  
+    class << self
+      
+      def prepare(&block)
+        @@matcher = RouteMatcher.new
+        @@generator = RouteGenerator.new
+      
+        yield self
+      
+        @@matcher.compile_router
+      end
+      
+      def add(*route)
+        @@matcher.add(*route)
+      end
+      
+      def matcher
+        @@matcher
+      end
+      
+      def generator
+        @@generator
+      end
+      
+      def match(path)
+        @@matcher.route_request(path)
+      end
+      
+      def generate(method, options = {})
+        @@generator.generate(method, options)
+      end
+      
+      def resources(res, opts={})
+        opts[:prefix] ||= ""
+        if block_given?
+          procs = []
+          yield Resource.new(res, procs, opts)
+          procs.reverse.each &:call
+        else
+          generate_resources_routes(res,opts)
+        end
+      end
+      
+      def resource(res, opts={})
+        opts[:prefix] ||= ""
+        if block_given?
+          procs = []
+          yield Resource.new(res, procs, opts)
+          procs.reverse.each &:call
+        else
+          generate_singleton_routes(res,opts)
+        end
+      end
+      
+      def default_routes
+        @@matcher.default_routes
+      end
+      
+      def compiled_statement
+        @@matcher.compiled_statement
+      end
+      
+      def compiled_regexen
+        @@matcher.compiled_regexen
+      end
+        
+      def generate_resources_routes(res, opts)
+        [@@matcher,@@generator].each { |r| r.generate_resources_routes(res, opts) }
+      end
+      
+      def generate_singleton_routes(res, opts)
+        [@@matcher,@@generator].each { |r| r.generate_singleton_routes(res, opts) }
+      end
 
-    # the final compiled lambda that gets used
-    # as the body of the route_request method.
-    def self.compiled_statement
-      @@compiled_statement
-    end
-    
-    def self.compiled_regexen
-      @@compiled_regexen
-    end
+    end # class << self
     
-    def compiled_statement
-      @@compiled_statement
-    end
-  
-    # add a route to be compiled
-    def self.add(*route)
-      @@routes << [route[0], (route[1] || {})]
+    class RouteMatcher
+            
+      def initialize
+        @routes = Array.new
+        @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
+      end
+      
+      def compiled_regexen
+        @compiled_regexen
+      end
+
+      # add a route to be compiled
+      def 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 compile_router
+        router_lambda = @routes.inject("lambda{|path| \n  sections={}\n  case path\n") { |m,r|
+          m << compile(r)
+        } << "  else\n    return {:controller=>'Noroutefound', :action=>'noroute'}\n  end\n}"
+        @compiled_statement = router_lambda
+        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.
+      def compile(route)
+        raise ArgumentError unless String === route[0]
+        code, count = '', 0
+        while route[0] =~ Router::SECTION_REGEXP
+          route[0] = route[0].dup
+          name = $1
+          (name =~ /(\*+)(\w+)/) ? (flag = true; name = $2) : (flag = false)
+          count += 1
+          if flag
+            route[0].sub!(Router::SECTION_REGEXP, "([^,?]+)")
+          else  
+            route[0].sub!(Router::SECTION_REGEXP, "([^\/,?]+)")
+          end
+          code << "    sections[:#{name}] = $#{count}\n"
+        end
+        @compiled_regexen << Regexp.new(route[0])
+        index = @compiled_regexen.size - 1
+        condition = "  when @compiled_regexen[#{index}] "
+        statement = "#{condition}\n#{code}"
+        statement << "    return #{route[1].inspect}.update(sections)\n"
+        statement
+      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'}
+          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
+            }
+          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
+            }
+          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'}
+        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'}
+        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'
+      end
     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  sections={}\n  case path\n") { |m,r|
-        m << compile(r)
-      } <<"  else\n    return {:controller=>'Noroutefound', :action=>'noroute'}\n  end\n}"
-      @@compiled_statement = router_lambda
-      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.
-    def self.compile(route)
-      raise ArgumentError unless String === route[0]
-      code, count = '', 0
-      while route[0] =~ @@section_regexp
-        route[0] = route[0].dup
-        name = $1
-        (name =~ /(\*+)(\w+)/) ? (flag = true; name = $2) : (flag = false)
-        count += 1
-        if flag
-          route[0].sub!(@@section_regexp, "([^,?]+)")
-        else  
-          route[0].sub!(@@section_regexp, "([^\/,?]+)")
+
+    class RouteGenerator
+
+      attr_accessor :paths
+
+      def initialize
+        @paths = {}
+      end
+
+      def add(name, path)
+        name = name.intern unless Symbol === name
+        @paths[name] = path
+      end
+
+      def generate(name, options = {})
+        path = @paths[name]
+        while path =~ Router::SECTION_REGEXP
+          path.sub!(Router::SECTION_REGEXP, options[$~[1].intern].to_s)
+        end
+        if f = options[:format]
+          "#{path}.#{f}"
+        else
+          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}"
+      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"
+        if mem = opt[:member]
+          mem.keys.sort_by{|x| "#{x}"}.each {|action|
+            add "#{action}_#{res_singular}", "#{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}"
+          }
         end
-        code << "    sections[:#{name}] = $#{count}\n"
-      end
-      @@compiled_regexen << Regexp.new(route[0])
-      index = @@compiled_regexen.size - 1
-      condition = "  when @@compiled_regexen[#{index}] "
-      statement = "#{condition}\n#{code}"
-      statement << "    return #{route[1].inspect}.update(sections)\n"
-      statement
+      end
     end
-    
+
     class Resource
-      # TODO : come up with naming convention and generate helper 
-      # methods for route generation. Route generation 
-      # framework needed but needs to be simple and light
       
       def initialize(resource, procs=[], opts={})
         @resource, @procs, @opts = resource, procs, opts
-        @procs << proc { ::Merb::RouteMatcher.generate_resources_routes(@resource, @opts) }
+        @procs << proc do
+           [::Merb::Router.matcher, ::Merb::Router.generator].each {|r| r.generate_resources_routes(@resource, @opts) } 
+        end
       end
 
       def resources(res, opts={})
@@ -101,7 +252,9 @@ module Merb
         if block_given?
           yield self.class.new(res, @procs, opts)
         else
-          @procs << proc { ::Merb::RouteMatcher.generate_resources_routes(res, opts) }
+          @procs << proc do
+             [::Merb::Router.matcher, ::Merb::Router.generator].each {|r| r.generate_resources_routes(res, opts) }
+          end
         end
       end
       
@@ -112,76 +265,11 @@ module Merb
         if block_given?
           yield self.class.new(res, @procs, opts)
         else
-          @procs << proc { ::Merb::RouteMatcher.generate_singleton_routes(res, opts) }
-        end
-      end
-    end
-      
-    # add a resource to be compiled for rest style dispatch
-    def self.resources(res, opts={})
-      opts[:prefix] ||= ""
-      if block_given?
-        procs = []
-        yield Resource.new(res, procs, opts)
-        procs.reverse.each &:call
-      else
-        generate_resources_routes(res,opts)
-      end
-    end
-    
-    # add a resource to be compiled for rest style dispatch
-    def self.resource(res, opts={})
-      opts[:prefix] ||= ""
-      if block_given?
-        procs = []
-        yield Resource.new(res, procs, opts)
-        procs.reverse.each &:call
-      else
-        generate_singleton_routes(res,opts)
-      end
-    end
-    
-    def self.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'}
-        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
-          }
+          @procs << proc do
+             [::Merb::Router.matcher, ::Merb::Router.generator].each { |r| r.generate_singleton_routes(res, opts) }
+          end   
         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
-          }
-        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'}
       end
     end
-    
-    def self.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'}
-      end
-    end
-    
-    def self.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'
-    end
   end
-
 end

data/lib/merb/merb_server.rb

@@ -91,6 +91,10 @@ 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|
+            options[:runner] = stuff_to_run
+          end
+          
           opts.on("-g", "--generate-app PATH", "Generate a fresh merb app at PATH") do |path|
             options[:generate] = path || Dir.pwd
           end
@@ -102,8 +106,8 @@ module Merb
           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
-          
-          opts.on("-X", "--mutex on/off", "This flag is for turnhing on and off the mutex lock.") do |mutex|
+         
+          opts.on("-X", "--mutex on/off", "This flag is for turning the mutex lock on and off.") do |mutex|
             if mutex == 'off'
               options[:use_mutex] = false
             else
@@ -191,6 +195,15 @@ module Merb
         
         if @@merb_opts[:console]
           initialize_merb
+          Object.class_eval do 
+            def show_routes
+              Merb::Router.generator.paths.each {|p| puts p.inspect}
+              nil
+            end
+            def url(path, o={})
+              Merb::Router.generator.generate(path,o)
+            end
+          end
           ARGV.clear # Avoid passing args to IRB 
           require 'irb' 
           require 'irb/completion' 
@@ -203,6 +216,17 @@ module Merb
           IRB.start
           exit!
         end
+
+        if @@merb_opts[:runner]
+          initialize_merb
+          code_or_file = @@merb_opts[:runner] 
+          if File.exists?(code_or_file)
+            eval(File.read(code_or_file))
+          else
+            eval(code_or_file)
+          end
+          exit!
+        end
         
         if @@merb_opts[:start_drb] 
           puts "Starting merb drb server on port: #{@@merb_opts[:drb_server_port]}"
@@ -220,7 +244,6 @@ module Merb
           delete_pidfiles(@@merb_opts[:port])
           start(@@merb_opts[:port])
         else
-          initialize_merb
           trap('TERM') { exit }
           mongrel_start(@@merb_opts[:port])
         end     

data/lib/merb/merb_view_context.rb

@@ -3,9 +3,22 @@ require File.dirname(__FILE__)+'/mixins/view_context_mixin'
 require File.dirname(__FILE__)+'/mixins/form_control_mixin'
 
 module Merb
-  PROTECTED_IVARS = %w[@cookies @session @headers @params 
-             @env @in @status @root @method @request @fingerprint_before
-             @_new_cookie @tmpl_ext_cache @body]
+  PROTECTED_IVARS = %w[@_new_cookie
+                       @method
+                       @env
+                       @body
+                       @_fingerprint_before
+                       @pager
+                       @session
+                       @headers
+                       @page
+                       @cookies
+                       @request
+                       @status
+                       @_view_context_cache
+                       @response
+                       @params]
+                       
   module GlobalHelper
   end    
   # the ViewContext is really
@@ -19,6 +32,7 @@ module Merb
     include Merb::GlobalHelper
     
     def initialize(controller)
+      @_merb_partial_locals = {}
       @controller = controller
       (@controller.instance_variables - PROTECTED_IVARS).each do |ivar|
         self.instance_variable_set(ivar, @controller.instance_variable_get(ivar))
@@ -43,7 +57,7 @@ module Merb
     alias_method :old_respond_to?, :respond_to?
     
     def respond_to?(sym, include_private=false)
-      old_respond_to?(sym, include_private) || @controller.respond_to?(sym, include_private)  
+      old_respond_to?(sym, include_private) || @controller.respond_to?(sym, include_private) || @_merb_partial_locals.key?(sym)
     end
     
     # catch any method calls that the controller responds to
@@ -51,6 +65,8 @@ module Merb
     def method_missing(sym, *args, &blk)
       if @controller.respond_to? sym
         @controller.send(sym, *args, &blk)
+      elsif @_merb_partial_locals.key? sym
+        @_merb_partial_locals[sym]
       else
         super
       end    

data/lib/merb/mixins/controller_mixin.rb

@@ -18,39 +18,46 @@ module Merb
       status = input.read(boundary_size)
       raise EOFError, "bad content body"  unless status == boundary + EOL
       rx = /(?:#{EOL})?#{Regexp.quote(boundary,'n')}(#{EOL}|--)/
-      
       loop {
         head = nil
         body = ''
         filename = content_type = name = nil
-      
+        read_size = 0
         until head && buf =~ rx
-          if !head && i = buf.index("\r\n\r\n")
+          i = buf.index("\r\n\r\n")
+          if( i == nil && read_size == 0 && content_length == 0 )
+            content_length = -1
+            break
+          end
+          if !head && i
             head = buf.slice!(0, i+2) # First \r\n
             buf.slice!(0, 2)          # Second \r\n
-      
             filename = head[FILENAME_REGEX, 1]
             content_type = head[CONTENT_TYPE_REGEX, 1]
             name = head[NAME_REGEX, 1]
             
-            if filename && !filename.empty?      
+            if filename && !filename.empty?    
               body = Tempfile.new(:Merb)
               body.binmode if defined? body.binmode
             end
             next
           end
-      
+
+          
           # Save the read body part.
           if head && (boundary_size+4 < buf.size)
             body << buf.slice!(0, buf.size - (boundary_size+4))
           end
       
-          c = input.read(bufsize < content_length ? bufsize : content_length)
-          raise EOFError, "bad content body"  if c.nil? || c.empty?
-          buf << c
-          content_length -= c.size
+          read_size = bufsize < content_length ? bufsize : content_length
+          if( read_size > 0 )
+            c = input.read(read_size)
+            raise EOFError, "bad content body"  if c.nil? || c.empty?
+            buf << c
+            content_length -= c.size
+          end
         end
-      
+
         # Save the rest.
         if i = buf.index(rx)
           body << buf.slice!(0, i)
@@ -58,7 +65,7 @@ module Merb
       
           content_length = -1  if $1 == "--"
         end
-      
+        
         if filename && !filename.empty?   
           body.rewind
           data = { 
@@ -92,6 +99,10 @@ module Merb
       parms
     end
     
+    def url(path, o={})
+      ::Merb::Router.generator.generate(path,o)
+    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
@@ -246,4 +257,4 @@ module Merb
     end
   
   end
-end
+end

data/lib/merb/mixins/form_control_mixin.rb

@@ -41,6 +41,11 @@ module Merb
           text(o)
         end
 
+        def hidden(o)
+          o.value ||= ""
+          %{<input type="hidden" name="#{o.name}" value="#{o.value}" #{o.html ? o.html.map{|k,v| "#{k}=\"#{v}\""}.join(' ') : nil}/>}
+        end
+        
         def text(o)
           o.value ||= ""
           tag = ''

data/lib/merb/mixins/render_mixin.rb

@@ -27,6 +27,9 @@ module Merb
     # render :nothing => 200
     # renders nothing with a status of 200
     #
+    # render :template => 'shared/message'
+    # renders views/shared/message
+    #
     # render :js => "$('some-div').toggle();"
     # if the right hand side of :js => is a string then the proper
     # javascript headers will be set and the string will be returned 
@@ -57,6 +60,13 @@ module Merb
       when partial = opts[:partial]
         template = find_partial(partial, opts)
         opts[:layout] = :none
+        
+        # Add an instance variable that can be used to create the locals in the
+        # partial
+        if opts[:locals]
+          @_merb_partial_locals = opts[:locals]
+        end
+        opts[:clean_context] = true
       when js = opts[:js]
         headers['Content-Type'] = "text/javascript"
         opts[:layout] = :none
@@ -71,14 +81,16 @@ module Merb
         headers['Content-Type'] = 'application/xml'
         headers['Encoding']     = 'UTF-8'
         return xml
-      else  
+      when template = opts[:template]
+        template = find_template(:template => template)
+      else          
         template = find_template(:action => action)
       end
         
       engine = engine_for(template)
       options = {
         :file     => template,
-        :view_context  => (opts[:clean_context] ? clean_view_context : _view_context),
+        :view_context  => (opts[:clean_context] ? clean_view_context : cached_view_context),
         :opts => opts
       }
       content = engine.transform(options)
@@ -92,7 +104,7 @@ module Merb
     # this returns a ViewContext object populated with all
     # the instance variables in your controller. This is used
     # as the view context object for the Erubis templates.
-    def _view_context
+    def cached_view_context
       @_view_context_cache ||= ViewContext.new(self)
     end
     
@@ -129,8 +141,8 @@ module Merb
     # you can render partials in other view directories. So
     # if you create a views/shared directory then you can call
     # partials that live there like partial('shared/foo')
-    def partial(template)
-      render :partial => template
+    def partial(template, locals={})
+      render :partial => template, :locals => locals
     end 
     
     private
@@ -146,11 +158,11 @@ module Merb
           end  
         end      
         
-        _view_context.instance_variable_set('@_layout_content', content)
+        cached_view_context.instance_variable_set('@_layout_content', content)
         engine = engine_for(layout_choice)
         options = {
           :file     => layout_choice,
-          :view_context  => _view_context,
+          :view_context  => cached_view_context,
           :opts => opts
         }
         engine.transform(options)
@@ -158,14 +170,15 @@ module Merb
       
       # OPTIMIZE : combine find_template and find_partial ?
       def find_template(opts={})
-        if action = opts[:action]
-          path =
-            File.expand_path(MERB_ROOT / "dist/app/views" / self.class.name.snake_case / action)
+        if template = opts[:template]
+          path = _template_root / template
+        elsif action = opts[:action]
+          path = _template_root / self.class.name.snake_case / action
         elsif _layout = opts[:layout]
           path = _layout_root / _layout
         else
           raise "called find_template without an :action or :layout"  
-        end  
+        end        
         extensions = [_template_extensions.keys].flatten.uniq
         glob = "#{path}.{#{opts[:ext] || extensions.join(',')}}"
         Dir[glob].first

data/lib/merb/mixins/view_context_mixin.rb

@@ -32,7 +32,7 @@ module Merb
       %{<img src="#{opts.delete(:path) + img}" #{opts.map{|k,v| "#{k}=\"#{v}\""}.join(' ')} />}
     end
     
-    # calls .to_json on data. This will use fjson if installed
+    # calls .to_json on data.
     # so it can be faster than escape_js
     def js(data)
       if data.respond_to? :to_json

data/lib/merb/template/haml.rb

@@ -27,9 +27,6 @@ module Merb
     
       class << self
         
-        class_inheritable_accessor :haml_options
-        self.haml_options = { :locals => {} }
-        
         @@hamls ||= {}
         @@mtimes ||= {}
         
@@ -39,16 +36,14 @@ module Merb
         
         def transform(options = {})
           opts, file, view_context = options.values_at(:opts, :file, :view_context)
-          opts = haml_options.merge(opts)
+          
          	begin 
-         	  if precompiled = get_precompiled(file) 
-         	    opts[:precompiled] ||= precompiled 
-         	    haml = ::Haml::Engine.new("", opts) 
-         	  else 
-         	    haml = ::Haml::Engine.new(IO.read(file), opts) 
-         	    set_precompiled(file, haml.precompiled) 
-         	  end 
-         	
+         	  locals_code = build_locals(opts[:locals])
+         	  opts[:locals] = {}
+         	  
+         	  template = load_template(file)
+         	  
+         	  haml = ::Haml::Engine.new("#{locals_code}#{template}", opts) 
          	  haml.to_html(view_context) 
          	rescue 
          	  # ::Haml::Engine often inserts a bogus "(haml):#{line_number}" entry in the backtrace. 
@@ -59,26 +54,37 @@ module Merb
         end
       
         private
+          def load_template(file)
+            template = ""
+            if @@hamls[file] && !cache_template?(file)
+              template = @@hamls[file]
+            else  
+              template = IO.read(file)
+              if cache_template?(file)
+                @@hamls[file], @@mtimes[file] = template, Time.now
+              end
+              return template
+            end
+          end
+          
+          def build_locals(locals)
+            locals_code = ""
+         	  if locals
+         	    locals_code = locals.keys.inject("") do |code, key| 
+                code << "- #{key} = @_merb_partial_locals[:#{key}]\n"
+              end
+            end
+          end
         
-        def get_precompiled(path, opts={})
-          if @@hamls[path] && !cache_template?(path)
-            return @@hamls[path]
-          end   
-        end
-        
-       def set_precompiled(path, precompiled)
-         @@hamls[path], @@mtimes[path] = precompiled, Time.now 
-       end
-        
-        def cache_template?(path)
-          return false unless ::Merb::Server.config[:cache_templates]
-          return true unless @@hamls[path]
-          @@mtimes[path] < File.mtime(path) ||
-            (File.symlink?(path) && (@@mtimes[path] < File.lstat(path).mtime))
-        end
+          def cache_template?(path)
+            return false unless ::Merb::Server.config[:cache_templates]
+            return true unless @@hamls[path]
+            @@mtimes[path] < File.mtime(path) ||
+              (File.symlink?(path) && (@@mtimes[path] < File.lstat(path).mtime))
+          end
         
       end
       
     end
   end
-end
+end

data/lib/merb/template/markaby.rb

@@ -33,8 +33,15 @@ module Merb
         # mab is just ruby, there's no two phase compile and run
         def transform(options = {})
           opts, file, view_context = options.values_at(:opts, :file, :view_context)
+          
+          if opts[:locals]
+            locals = opts[:locals].keys.inject("") do |code, key| 
+              code << "#{key} = @_merb_partial_locals[:#{key}]\n"
+            end
+          end
+          
           mab = ::Markaby::Builder.new({}, view_context) {
-            instance_eval(File.read(file))
+            instance_eval("#{locals}#{File.read(file)}")
           }
           mab.to_s
         end

data/lib/tasks/merb.rake

@@ -21,4 +21,12 @@ namespace :merb do
     puts "   - #{MERB_ROOT / 'dist/framework'} (recursive) "
     puts "   - #{MERB_ROOT / 'script/merb'}"
   end
+  
+  desc "freeze the merb framework from svn"
+  task :freeze_from_svn do
+    puts "Freezing Merb Framework from svn"
+    FileUtils.rm_rf MERB_ROOT / 'dist/framework'
+    system "svn co http://svn.devjavu.com/merb/trunk/lib #{MERB_ROOT / 'dist/framework'}"
+  end
+  
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: merb
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
-date: 2007-04-30 00:00:00 -07:00
+  version: 0.3.3
+date: 2007-05-31 00:00:00 -07:00
 summary: Merb == Mongrel + Erb. Pocket rocket web framework.
 require_paths: 
 - lib
@@ -175,3 +175,30 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 0.0.0
     version: 
+- !ruby/object:Gem::Dependency 
+  name: mime-types
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: xml-simple
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: archive-tar-minitar
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: