merb 0.1.0 → 0.2.0

data/README

@@ -6,8 +6,6 @@ Merb. Mongrel+Erb
 Little bitty lightweight ruby app server. For when you really need performance
 for simple dynamic pages.
 
-**Sample APP included**
-
 ** Dependencies **
 mongrel
 erubis
@@ -36,36 +34,95 @@ 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. So the following routes:
+a method on the fly that will match the request path against each route and do the right thing.
+
+*** NEW RESTFULL ROUTES ***
+
+note the r.resource :posts macro. That makes it possible to use a restfull crud style controller for the posts resource
 
 Merb::RouteMatcher.prepare do |r|
-  r.add '/foo/:bar/baz/:id', :controller => 'Test', :action => 'foo'
+  r.resources :posts
   r.add '/:controller/:action/:id'
-  r.add '/bar/:*rest', :controller => 'Test', :action => 'glob'
+  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('/foo/([^/;.,?]+)/baz/([^/;.,?]+)')
-    @sections[:bar] = $1
-    @sections[:id] = $2
-    return {:controller=>"Test", :action=>"foo"}.merge(@sections)
+  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 || nil
+      @sections[:id] = $3 if $3
       return @sections
-  when Regexp.new('/bar/([^;.,?]+)')
-    @sections[:rest] = $1
-    return {:controller=>"Test", :action=>"glob"}.merge(@sections)
+  when Regexp.new('/')
+    return {:controller=>"files", :action=>"index"}.update(@sections)
   else
     return {:controller=>'Noroutefound', :action=>'noroute'}
   end
 }
 
+
+*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
 with instance vars available in the views automatically. Merb also supports 

data/Rakefile

@@ -4,24 +4,19 @@ require 'rake/gempackagetask'
 require 'rake/rdoctask'
 require 'rake/testtask'
 require 'spec/rake/spectask'
-require 'code_statistics' 
 require 'fileutils'
 def __DIR__
   File.dirname(__FILE__)
 end
 
 require __DIR__+'/tools/rakehelp'
+require __DIR__+'/tools/annotation_extract'
 include FileUtils
 
 
 NAME = "merb"
-VERS = "0.1.0"
+VERS = "0.2.0"
 CLEAN.include ['**/.*.sw?', '*.gem', '.config']
-RDOC_OPTS = ['--quiet', '--title', "Merb Documentation",
-  "--opname", "index.html",
-  "--line-numbers", 'TODO',
-  "--main", "README",
-  "--inline-source"]
 
 setup_clean [ "pkg", "lib/*.bundle", "*.gem", 
             "doc", ".config", "examples/sample_app/dist/public/files/**/*", 'examples/sample_app/log/*']
@@ -34,22 +29,33 @@ 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|
-  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']
+     files =['README', 'LICENSE', 'TODO', 'lib/**/*.rb']
+     rdoc.rdoc_files.add(files)
+     rdoc.main = "README" # page to start on
+     rdoc.title = "Merb Docs"
+     rdoc.template = __DIR__+"/tools/allison/allison.rb"
+     rdoc.rdoc_dir = 'doc' # rdoc output folder
+     rdoc.options << '--line-numbers' << '--inline-source'
 end
 
+
+
 spec = Gem::Specification.new do |s|
   s.name = NAME
   s.version = VERS
   s.platform = Gem::Platform::RUBY
   s.has_rdoc = true
   s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
-  s.rdoc_options += RDOC_OPTS + 
-    ['--exclude', '^(app|uploads)']
+  #s.rdoc_options += RDOC_OPTS + 
+  #  ['--exclude', '^(app|uploads)']
   s.summary = "Merb == Mongrel + Erb. Pocket rocket web framework."
   s.description = s.summary
   s.author = "Ezra Zygmuntowicz"
@@ -144,23 +150,6 @@ Spec::Rake::SpecTask.new('rcov') do |t|
   t.rcov = true
 end
 
-##############################################################################
-# Statistics
-##############################################################################
-
-STATS_DIRECTORIES = [
-  %w(Code               lib/),
-  %w(Unit\ tests        test/unit),
-  %w(Functional\ tests  test/functional)
-].collect { |name, dir| [ name, "./#{dir}" ] }.select { |name, dir| File.directory?(dir) }
-
-desc "Report code statistics (KLOCs, etc) from the application"
-task :stats do
-  #require 'extra/stats'
-  verbose = true
-  CodeStatistics.new(*STATS_DIRECTORIES).to_s
-end
-
 ##############################################################################
 # SVN
 ##############################################################################

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

@@ -5,8 +5,8 @@ class AddSessionsTable < ActiveRecord::Migration
         t.column :session_id,      :string,  :limit => 32
         t.column :created_at,  :datetime
         t.column :data,       :text
-        add_index "sessions", ["session_id"], :name => "session_id_index"
     end
+     add_index "sessions", ["session_id"], :name => "session_id_index"
   end
 
   def self.down

data/lib/merb.rb

@@ -12,7 +12,7 @@ end
 
 
 module Merb
-  VERSION='0.1.0' unless defined?VERSION
+  VERSION='0.2.0' unless defined?VERSION
   class Server
     class << self
       def config
@@ -47,6 +47,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]
 
 logpath = $TESTING ? "/tmp/merb_test.log" : "#{MERB_ROOT}/log/merb.#{Merb::Server.port}.log"
 MERB_LOGGER = Logger.new(logpath)
@@ -101,4 +102,4 @@ class Merb::Controller
     include ::Merb::Authentication
     puts "Basic Authentication mixed in"
   end
-end  
+end

data/lib/merb/caching.rb

@@ -0,0 +1,5 @@
+corelib = __DIR__+'/merb/caching'
+
+%w[ action_cache
+    fragment_cache
+  ].each {|fn| require File.join(corelib, fn)}

data/lib/merb/caching/action_cache.rb

@@ -0,0 +1,56 @@
+module Merb
+  module Caching
+  
+    module Actions 
+  
+      def self.included(base) # :nodoc: 
+        base.class_eval {
+          def caching_enabled?
+            @_caching_enabled ||= ::Merb::Server.cache_templates
+          end
+        }
+        base.extend(ClassMethods)
+      end
+  
+      module ClassMethods
+  
+        # Cache the given actions.
+        
+        def cache_action(*actions)
+          return unless caching_enabled?
+          before :_get_action_fragment, :only => actions        
+          after :_store_action_fragment, :only => actions
+        end
+        
+      end
+  
+      private 
+  
+      def _get_action_fragment
+        fragment_name = "#{params[:action]}#{@request.query_string}"
+        if fragment = ::Merb::Caching::Fragment.get(fragment_name)
+          throw :halt, fragment
+        end
+      end
+  
+      def _store_action_fragment
+        fragment_name = "#{params[:action]}#{@request.query_string}"
+        ::Merb::Caching::Fragment.put(fragment_name, @body)
+      end
+  
+      def caching_enabled?
+        @_caching_enabled ||= ::Merb::Server.cache_templates
+      end
+      
+      def expire_action(*actions)
+        return unless caching_enabled?
+        for action in [actions].flatten
+          expire_fragment(action)
+        end
+      end
+  
+    end
+  
+  end
+  
+end  

data/lib/merb/caching/fragment_cache.rb

@@ -0,0 +1,38 @@
+module Merb
+  module Caching
+    module Fragment
+      class << self
+        def cache
+          @cache ||= determine_cache_store
+        end
+        
+        def get(name)
+          cache.get(name)
+        end
+        
+        def put(name, content = nil)
+          cache.put(name, content)
+          content
+        end
+        
+        def expire_fragment(name)
+          cache.delete(name)
+        end
+        
+        def determine_cache_store
+          case ::Merb::Server.cache_store
+          when "file", :file
+            require 'merb/caching/store/file_cache'
+            ::Merb::Caching::Store::FileCache.new
+          when "memory", :memory
+            require 'merb/caching/store/memory_cache'
+            ::Merb::Caching::Store::MemoryCache.new
+          else
+            require 'merb/caching/store/memory_cache'            
+            ::Merb::Caching::Store::MemoryCache.new
+          end    
+        end  
+      end
+    end
+  end
+end

data/lib/merb/caching/store/file_cache.rb

@@ -0,0 +1,82 @@
+require 'uri'
+require 'fileutils'
+require 'tmpdir'
+
+module Merb
+  module Caching
+    module Store
+ 
+      class FileCache
+            
+        def initialize(name = "cache", keepalive = nil)
+          @path = File.join(MERB_ROOT, name)
+          @keepalive = keepalive
+      
+          FileUtils.mkdir_p(@path, :mode => 0700)
+        end
+      
+        def []=(k,v)
+          fn = File.join(@path, escape_filename(k.to_s) )
+          encode_file(fn, v)
+        end
+        alias :put :[]=
+        alias :write :[]=
+        
+        def [](k)
+          fn = File.join(@path, escape_filename(k.to_s) )
+          return nil unless File.exists?(fn)
+          decode_file(fn)
+        end
+        alias :get :[]
+        alias_method :read, :[]
+      
+        def delete(k)
+          f = File.join(@path, escape_filename(k.to_s))
+          File.delete(f) if File.exists?(f)
+        end
+        
+        def gc!
+          return unless @keepalive
+      
+          now = Time.now
+          all.each do |fn|
+            expire_time = File.stat(fn).atime + @keepalive 
+            File.delete(fn) if now > expire_time
+          end
+        end
+
+        private
+      
+        def decode_file(fn)
+          val = nil
+          File.open(fn,"rb") do |f|
+            f.flock(File::LOCK_EX)
+            val = Marshal.load( f.read )
+            f.flock(File::LOCK_UN)
+          end
+          return val
+        end
+      
+        def encode_file(fn, value)
+          File.open(fn, "wb") do |f| 
+            f.flock(File::LOCK_EX)
+            f.chmod(0600)
+            f.write(Marshal.dump(value))
+            f.flock(File::LOCK_UN)
+          end
+        end
+        
+        def all
+          Dir.glob( File.join(@path, '*' ) )
+        end
+        # need this for fat filesystems
+        def escape_filename(fn)
+          URI.escape(fn, /["\/:;|=,\[\]]/)
+        end
+      
+      end
+      
+    end
+  end
+end
+

data/lib/merb/caching/store/memory_cache.rb

@@ -0,0 +1,67 @@
+module Merb
+  module Caching
+    module Store
+      
+      class MemoryCache
+      
+        def initialize(opts={})
+          @opts = opts
+          @cache = Hash.new
+          @timestamps = Hash.new
+          @mutex = Mutex.new
+          @cache_ttl = @opts.fetch(:session_ttl, 30*60) # default 30 minutes
+        end
+        
+        def [](key)
+          @mutex.synchronize {
+            @timestamps[key] = Time.now
+            @cache[key]
+          }
+        end
+        alias_method :get, :[]
+        alias_method :read, :[]
+         
+        def []=(key, val) 
+          @mutex.synchronize {
+            @timestamps[key] = Time.now
+            @cache[key] = val
+          } 
+        end
+        alias_method :put, :[]=
+        alias_method :write, :[]=
+        
+        def delete(key)
+          @mutex.synchronize {
+            @cache.delete(key)
+          }
+        end
+        alias_method :remove, :delete
+        
+        def delete_if(&block)
+          @hash.delete_if(&block)
+        end
+        
+        def reap_old_caches
+          @timestamps.each do |key,stamp|
+            if stamp + @cache_ttl < Time.now
+              delete(key)
+            end  
+          end
+          GC.start
+        end  
+        
+        def cache
+          @cache
+        end  
+        
+        def keys
+          @cache.keys 
+        end  
+              
+      end 
+    
+    end
+  
+  end    
+  
+end