manveru-ramaze 2008.12 → 2009.01

data/lib/proto/public/.htaccess

@@ -0,0 +1,24 @@
+# General Apache options
+Options +FollowSymLinks +ExecCGI
+AddHandler cgi-script cgi rb
+<IfModule mod_fastcgi.c>
+ AddHandler fastcgi-script fcgi
+</IfModule>
+<IfModule mod_fcgid.c>
+ AddHandler fcgid-script fcgi
+</IfModule>
+
+# Redirect all requests not available on the filesystem to Ramaze.
+
+RewriteEngine On
+RewriteCond %{REQUEST_FILENAME} !-f
+RewriteRule ^(.*)$ dispatch.fcgi [QSA,L]
+
+# In case Ramaze experiences terminal errors.
+# Instead of displaying this message you can supply a
+# file here which will be rendered instead.
+#
+# Example:
+#   ErrorDocument 500 /500.html
+
+ErrorDocument 500 "<h2>Application error</h2>Ramaze failed to start properly"

data/lib/ramaze/action/render.rb

@@ -49,8 +49,8 @@ module Ramaze
     # true.
 
     def cached_render
-      if Global.file_cache
-        cached_render_file
+      if cache_root = Global.file_cache
+        cached_render_file(cache_root)
       else
         cached_render_memory
       end
@@ -59,12 +59,13 @@ module Ramaze
     # Uses files in the Global.public_root to provide a static ressource on
     # next request and returns the rendered action
 
-    def cached_render_file
+    def cached_render_file(cache_root)
       rendered = uncached_render
 
-      global_epath = Global.public_root/self.controller.mapping/extended_path
+      cr = cache_root.respond_to?(:to_str) ? cache_root.to_str : Global.public_root
+      global_epath = File.join(cr, self.controller.mapping, extended_path)
       FileUtils.mkdir_p(File.dirname(global_epath))
-      File.open(global_epath, 'w+') {|fp| fp.print(rendered) }
+      File.open(global_epath, 'w+'){|fp| fp.print(rendered) }
 
       rendered
     end

data/lib/ramaze/controller/resolve.rb

@@ -16,7 +16,7 @@ module Ramaze
       # instead, in either case with path as argument.
 
       def resolve(path, routed = false)
-        @routed = routed
+        Thread.current[:routed] = routed
 
         FILTER.each do |filter|
           answer = if filter.respond_to?(:call)
@@ -90,7 +90,7 @@ module Ramaze
           end
         end
 
-        if !@routed and new_path = Route.resolve(path)
+        if !Thread.current[:routed] and new_path = Route.resolve(path)
           Log.dev("Routing from `#{path}' to `#{new_path}'")
           return resolve(new_path, true)
         end

data/lib/ramaze/current/request.rb

@@ -196,9 +196,9 @@ module Ramaze
     # Example:
     #   request.params
     #   # => {'name' => 'jason', 'age' => '45', 'job' => 'lumberjack'}
-    #   request.sub('name')
+    #   request.subset('name')
     #   # => {'name' => 'jason'}
-    #   request.sub(:name, :job)
+    #   request.subset(:name, :job)
     #   # => {'name' => 'jason', 'job' => 'lumberjack'}
 
     def subset(*keys)

data/lib/ramaze/helper/bench.rb

@@ -0,0 +1,43 @@
+require 'benchmark'
+
+module Ramaze
+  module Helper
+
+    # Little helper to give you a hand when benching parts of actions
+
+    module Bench
+
+      # Will first run an empty loop to determine the overhead it imposes, then
+      # goes on to yield your block +iterations+ times.
+      #
+      # The last yielded return value will be returned upon completion of the
+      # benchmark and the result of the benchmark itself will be sent to
+      # Log.info
+      #
+      # Example:
+      #
+      #   class MainController < Ramaze::Controller
+      #     def index
+      #       @users = bench{ User.all }
+      #       @tags = bench{ Article.tags }
+      #     end
+      #   end
+      #
+      # This will show something like following in your log:
+      # [..] INFO   Bench ./start.rb:3:in `index': 0.121163845062256
+      # [..] INFO   Bench ./start.rb:4:in `index': 2.234987235098341
+      #
+      # So now we know that the Article.tags call takes the most time and
+      # should be improved.
+
+      def bench(iterations = 1)
+        result = nil
+        from = caller[0]
+        delta = Benchmark.realtime{ iterations.times{ nil }}
+        taken = Benchmark.realtime{ iterations.times{ result = yield }}
+        Log.info "Bench #{from}: #{taken - delta}"
+        return result
+      end
+    end
+  end
+end

data/lib/ramaze/helper/markaby.rb

@@ -15,7 +15,7 @@ module Ramaze
     def markaby(ivs = {}, helpers = nil, &block)
       builder = ::Markaby::Builder
       builder.extend(Ramaze::Helper::Methods)
-      builder.send(:helper, :link)
+      builder.send(:helper, :redirect, :link, :sendfile, :flash, :cgi, :partial)
 
       iv_hash = {}
       instance_variables.each do |iv|

data/lib/ramaze/helper/paginate.rb

@@ -165,7 +165,7 @@ module Ramaze
           text = h(text.to_s)
 
           params = Ramaze::Request.current.params.merge(@var.to_s => n)
-          name = Ramaze::Request.current.request_path
+          name = Ramaze::Request.current.path_info
           hash[:href] = R(name, params)
 
           g.a(hash){ text }

data/lib/ramaze/option.rb

@@ -78,7 +78,7 @@ module Ramaze
     o "Turn on customized error pages. Use Rack::ShowException otherwise.",
       :error_page, true, :cli => true
 
-    o "Caching actions to the filesystem in Global.public_root",
+    o "Cache actions to filesystem, uses String as directory name or Global.public_root if other truism",
       :file_cache, false, :cli => false
 
     o "Specify what IP Ramaze will respond to - 0.0.0.0 for all",

data/lib/ramaze/reloader/watch_inotify.rb

@@ -1,57 +1,62 @@
 module Ramaze
   class Reloader
+    # TODO:
+    #   * There seems to be a problem somewhere that I couldn't identify yet, a
+    #     file has to be modified twice initially to make it show up as
+    #     modified here, subsequent changes work just fine.
+    #     The only workaround I could find right now would be to read/write
+    #     every single file, but that would be unexpected, irresponsible, and
+    #     error-prone.
+    #
+    # NOTE:
+    #   * I have changed from using a Mutex to using a Queue, which uses a
+    #     Mutex internally.
+
     class WatchInotify
       POLL_INTERVAL = 2 # seconds
+      NOTIFY_MASK = RInotify::MODIFY | RInotify::IN_ONESHOT
 
       def initialize
         @watcher = RInotify.new
-        @changed = []
-        @mutex = Mutex.new
+        @changed = Queue.new
         @watcher_thread = start_watcher
       end
 
       def call(cooldown)
-        yield if @changed.any?
+        yield
       end
 
       # TODO: define a finalizer to cleanup? -- reloader never calls #close
 
       def start_watcher
-        Thread.new do
-          loop do
-            watcher_cycle
-            sleep POLL_INTERVAL
-          end
-        end
+        Thread.new{ loop{ watcher_cycle }}
       end
 
+      # Not much work here, we just have to empty the event queue and push the
+      # descriptors for reloading on next request.
       def watcher_cycle
-        return unless @watcher.wait_for_events(0)
-        changed_descriptors = []
+        return unless @watcher.wait_for_events(POLL_INTERVAL)
 
         @watcher.each_event do |event|
-          changed_descriptors << event.watch_descriptor
-        end
-
-        @mutex.synchronize do
-          changed_descriptors.each do |descriptor|
-            @changed << @watcher.watch_descriptors[descriptor]
-          end
+          @changed.push(event.watch_descriptor)
         end
       end
 
       def watch(file)
-        return false if @watcher.watch_descriptors.has_value?(file)
-        return false unless File.exist?(file)
+        return if @watcher.watch_descriptors.has_value?(file)
+        return unless File.exist?(file)
 
-        @mutex.synchronize{ @watcher.add_watch(file, RInotify::MODIFY) }
-
-        true
+        @watcher.add_watch(file, NOTIFY_MASK)
+      rescue Errno::ENOENT
+        retry
       end
 
+      # FIXME:
+      #   Seems like this won't work due to some bug in the rinotify library.
+      #   Would be cool if someone could make a FFI version.
+
       def remove_watch(file)
-        @mutex.synchronize{ @watcher.rm_watch(file) }
-        true
+        @watcher.rm_watch(file)
       end
 
       def close
@@ -60,13 +65,20 @@ module Ramaze
         true
       end
 
+      # NOTE:
+      #   We have to add the changed file again after we got a notification, I
+      #   have no idea why, but using IN_ONESHOT should make sure that there is
+      #   no memory leak in the C level even if we add a file again.
+      #   There is a memory leak however in the watch_descriptors hash, since
+      #   rinotify won't synchronize the contents properly and will only add to
+      #   the hash, so we have to clean up ourselves.
       def changed_files
-        @mutex.synchronize do
-          @tmp = @changed
-          @changed = []
+        until @changed.empty?
+          descriptor = @changed.shift
+          file = @watcher.watch_descriptors.delete(descriptor)
+          watch(file)
+          yield(file)
         end
-        @tmp.uniq!
-        @tmp
       end
     end
   end

data/lib/ramaze/reloader/watch_stat.rb

@@ -38,18 +38,14 @@ module Ramaze
 
       # return files changed since last call
       def changed_files
-        changed = []
-
         @files.each do |file, stat|
           if new_stat = safe_stat(file)
             if new_stat.mtime > stat.mtime
-              changed << file
               @files[file] = new_stat
+              yield(file)
             end
           end
         end
-
-        changed
       end
 
       def safe_stat(file)

data/lib/ramaze/reloader.rb

@@ -88,7 +88,7 @@ module Ramaze
       before_cycle
 
       rotation{|file| @watcher.watch(file) }
-      @watcher.changed_files.each{|f| safe_load(f) }
+      @watcher.changed_files{|f| safe_load(f) }
 
       after_cycle
     end

data/lib/ramaze/version.rb

@@ -2,5 +2,5 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
-  VERSION = "2008.10"
+  VERSION = "2009.01"
 end