ramaze 2008.11 → 2009.01

data/lib/ramaze/helper/user.rb

@@ -8,10 +8,10 @@ module Ramaze
     #
     # class MainController < Ramaze::Controller
     #   def index
-    #     if user?
-    #       A('login', :href => Rs(:login))
-    #     else
+    #     if logged_in?
     #       "Hello #{user.name}"
+    #     else
+    #       A('login', :href => Rs(:login))
     #     end
     #   end
     #
@@ -77,7 +77,7 @@ module Ramaze
           elsif _model.respond_to?(:authenticate)
             _model.authenticate(creds)
           else
-            Log.warn("Helper::User has no callback and %p doesn't respond to #authenticate" % _model)
+            Log.warn("Helper::User has no callback and there is no %p::authenticate" % _model)
             nil
           end
         end

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/option/holder.rb

@@ -78,7 +78,7 @@ module Ramaze
       # currently set one.
       def public_root
         [ @public_root,
-          root/@public_root
+          File.join(root, @public_root)
         ].find{|path| File.directory?(path) } || @public_root
       end
 
@@ -90,8 +90,8 @@ module Ramaze
       # the currently set one.
       def view_root
         [ @view_root,
-          root/@view_root,
-          root/'template',
+          File.join(root, @view_root),
+          File.join(root, 'template'),
         ].find{|path| File.directory?(path) } || @view_root
       end
 

data/lib/ramaze/reloader.rb

@@ -11,9 +11,7 @@ module Ramaze
   # Reloader::Hooks module or include your own module to override the hooks.
   # You also might have to set the Log constant.
   #
-  # What makes it especially suited for use in a production environment is that
-  # any file will only be checked once and there will only be made one system
-  # call stat(2).
+  # Currently, it uses RInotify if available and falls back to using File.stat.
   #
   # Please note that this will not reload files in the background, it does so
   # only when actively called
@@ -47,11 +45,21 @@ module Ramaze
       :control => nil, # lambda{ cycle },
     }
 
+    begin
+      gem 'RInotify', '>=0.9' # is older version ok?
+      require 'rinotify'
+      require 'ramaze/reloader/watch_inotify'
+      Watcher = WatchInotify
+    rescue LoadError
+      # stat always available
+      require 'ramaze/reloader/watch_stat'
+      Watcher = WatchStat
+    end
+
     def initialize(app)
       @app = app
-      @last = Time.now
-      @mtimes = {}
-      @cache = {}
+      @files = {}
+      @watcher = Watcher.new
       options_reload
     end
 
@@ -63,7 +71,7 @@ module Ramaze
     def call(env)
       options_reload
 
-      if @cooldown and Time.now > @last + @cooldown
+      @watcher.call(@cooldown) do
         if @control
           instance_eval(&@control)
         elsif @thread
@@ -71,8 +79,6 @@ module Ramaze
         else
           cycle
         end
-
-        @last = Time.now
       end
 
       @app.call(env)
@@ -81,16 +87,8 @@ module Ramaze
     def cycle
       before_cycle
 
-      rotation do |file, stat|
-        if mtime = stat.mtime
-          if mtime > (@mtimes[file] ||= mtime)
-            safe_load(file)
-            @mtimes[file] = mtime
-          end
-        else
-          @cache.delete(file)
-        end
-      end
+      rotation{|file| @watcher.watch(file) }
+      @watcher.changed_files{|f| safe_load(f) }
 
       after_cycle
     end
@@ -111,37 +109,23 @@ module Ramaze
 
       files.each do |file|
         next if file =~ @ignore
-        path, stat = figure_path(file, paths)
-
-        if path and stat
-          @cache[file] = path
-          yield(path, stat)
-        else
-          # Quite harmless, we just couldn't figure out path for #{file}
+        if not @files.has_key?(file) and path = figure_path(file, paths)
+          @files[file] = path
+          yield path
         end
       end
     end
 
     def figure_path(file, paths)
-      if cached = @cache[file]
-        stat = File.stat(cached)
-        return cached, stat if stat.file?
-      elsif Pathname.new(file).absolute?
-        stat = File.stat(file)
-        return file, stat if stat.file? # do directories really end up in $" ?
+      if Pathname.new(file).absolute?
+        return File.exist?(file) ? file : nil
       end
 
       paths.each do |possible_path|
-        path = File.join(possible_path, file)
-
-        begin
-          stat = File.stat(path)
-          return path, stat if stat.file?
-        rescue Errno::ENOENT, Errno::ENOTDIR
-        end
+        full_path = File.join(possible_path, file)
+        return full_path if File.exist?(full_path)
       end
-
-      return nil
+      nil
     end
 
 

data/lib/ramaze/reloader/watch_inotify.rb

@@ -0,0 +1,85 @@
+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 = Queue.new
+        @watcher_thread = start_watcher
+      end
+
+      def call(cooldown)
+        yield
+      end
+
+      # TODO: define a finalizer to cleanup? -- reloader never calls #close
+
+      def start_watcher
+        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(POLL_INTERVAL)
+
+        @watcher.each_event do |event|
+          @changed.push(event.watch_descriptor)
+        end
+      end
+
+      def watch(file)
+        return if @watcher.watch_descriptors.has_value?(file)
+        return unless File.exist?(file)
+
+        @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)
+        @watcher.rm_watch(file)
+      end
+
+      def close
+        @watcher_thread.terminate
+        @watcher.close
+        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
+        until @changed.empty?
+          descriptor = @changed.shift
+          file = @watcher.watch_descriptors.delete(descriptor)
+          watch(file)
+          yield(file)
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/reloader/watch_stat.rb

@@ -0,0 +1,58 @@
+module Ramaze
+  class Reloader
+    class WatchStat
+      def initialize
+        # @files[file_path] = stat
+        @files = {}
+        @last = Time.now
+      end
+
+      def call(cooldown)
+        if cooldown and Time.now > @last + cooldown
+          yield
+          @last = Time.now
+        end
+      end
+
+      # start watching a file for changes
+      # true if succeeded, false if failure
+      def watch(file)
+        return true if watching?(file) # if already watching
+        if stat = safe_stat(file)
+          @files[file] = stat
+        end
+      end
+
+      def watching?(file)
+        @files.has_key?(file)
+      end
+
+      # stop watching a file for changes
+      def remove_watch(file)
+        @files.delete(file)
+      end
+
+      # no need for cleanup
+      def close
+      end
+
+      # return files changed since last call
+      def changed_files
+        @files.each do |file, stat|
+          if new_stat = safe_stat(file)
+            if new_stat.mtime > stat.mtime
+              @files[file] = new_stat
+              yield(file)
+            end
+          end
+        end
+      end
+
+      def safe_stat(file)
+        File.stat(file)
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        nil
+      end
+    end
+  end
+end

data/lib/ramaze/snippets/divide.rb

@@ -6,6 +6,7 @@ class String
   # Usage:
   #   'a' / 'b' # => 'a/b'
   def / obj
+    Ramaze.deprecated('String#/', 'File::join')
     File.join(self, obj.to_s)
   end
 end
@@ -15,6 +16,7 @@ class Symbol
   # Usage:
   #   :dir/:file # => 'dir/file'
   def / obj
+    Ramaze.deprecated('Symbol#/', 'File::join(sym.to_s)')
     self.to_s / obj
   end
 end

data/lib/ramaze/snippets/numeric/time.rb

@@ -41,7 +41,7 @@ module Ramaze
 
       # 365.25 days in a year
       def years
-        self * 883612800
+        self * 31557600
       end
       alias year years
 

data/lib/ramaze/snippets/object/__dir__.rb

@@ -16,11 +16,11 @@ module Ramaze
         # This method is convenience for the
         #  File.expand_path(File.dirname(__FILE__))
         # idiom.
-        #
 
-        def __DIR__()
+        def __DIR__(*args)
           filename = caller[0][/^(.*):/, 1]
-          File.expand_path(File.dirname(filename))
+          dir = File.expand_path(File.dirname(filename))
+          ::File.expand_path(::File.join(dir, *args.map{|a| a.to_s}))
         end
       end
     end

data/lib/ramaze/snippets/object/acquire.rb

@@ -27,12 +27,9 @@ module Ramaze
       #   # require 'src/foo.rb' and 'src/bar.so' and 'src/foobar/baz.rb'
       #   acquire 'src/*', 'src/foobar/*'
 
-      def acquire *globs
-        globs.flatten.each do |glob|
-          Dir[glob].each do |file|
-            require file if file =~ /\.(rb|so)$/
-          end
-        end
+      def acquire(*globs)
+        Ramaze.deprecated('Object#acquire', 'Ramaze::acquire')
+        Ramaze.acquire(*globs)
       end
     end
 

data/lib/ramaze/snippets/ramaze/acquire.rb

@@ -0,0 +1,31 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  # Require all .rb and .so files on the given globs, utilizes Dir::[].
+  #
+  # Examples:
+  #   # Given following directory structure:
+  #   # src/foo.rb
+  #   # src/bar.so
+  #   # src/foo.yaml
+  #   # src/foobar/baz.rb
+  #   # src/foobar/README
+  #
+  #   # requires all files in 'src':
+  #   Ramaze.acquire 'src/*'
+  #
+  #   # requires all files in 'src' recursive:
+  #   Ramaze.acquire 'src/**/*'
+  #
+  #   # require 'src/foo.rb' and 'src/bar.so' and 'src/foobar/baz.rb'
+  #   Ramaze.acquire 'src/*', 'src/foobar/*'
+
+  def self.acquire(*globs)
+    globs.flatten.each do |glob|
+      Dir[glob].each do |file|
+        require file if file =~ /\.(rb|so)$/
+      end
+    end
+  end
+end

data/lib/ramaze/snippets/ramaze/deprecated.rb

@@ -6,7 +6,8 @@ module Ramaze
   def self.deprecated(from, to = nil)
     message = "%s is deprecated"
     message << ", use %s instead" unless to.nil?
-    Log.warn(message % [from, to])
+    message << " - from: %p"
+    Log.warn(message % [from, to, caller[1]])
   end
 
   def self.const_missing(name)

data/lib/ramaze/spec/helper/mock_http.rb

@@ -42,8 +42,9 @@ module MockHTTP
 
   def process_request(path, query)
     options = {}
-    FISHING.each{|key, value|
-      options[value] = query.delete(key)} if query.is_a?(Hash)
+    FISHING.each do |key, value|
+      options[value] = query.delete(key) if query.key?(key)
+    end if query.is_a?(Hash)
     [create_url(path, query), options]
   end
 
@@ -54,10 +55,10 @@ module MockHTTP
     uri.to_s
   end
 
-	def make_query query
-		return query unless query and not query.is_a?(String)
+  def make_query query
+    return query unless query and not query.is_a?(String)
     query.map{|key, value|
       "#{Rack::Utils.escape(key)}=#{Rack::Utils.escape(value)}"
     }.join('&')
-	end
+  end
 end

data/lib/ramaze/template/ezamar/render_partial.rb

@@ -7,6 +7,14 @@ require 'ramaze/template/ezamar/engine'
 module Ezamar
 
   # A transformer for <render /> tags.
+  #
+  # Setup:
+  #
+  #     pipeline = Ramaze::Template::Ezamar::TRANSFORM_PIPELINE
+  #     pipeline.put_after(::Ezamar::Element, ::Ezamar::RenderPartial)
+  #     pipline.uniq!
+  #
+  # See /examples/basic/partial.rb for usage.
 
   class RenderPartial
     extend Ramaze::Helper::Partial