Pistos-ramaze 2008.09 → 2008.12

data/lib/ramaze/helper/partial.rb

@@ -69,7 +69,7 @@ module Ramaze
       else
         roots = [options[:controller].template_paths].flatten
 
-        if (files = Dir["{#{roots.join(',')}}"/"{#{file},#{file}.*}"]).any?
+        if (files = Dir[File.join("{#{roots.join(',')}}","{#{file},#{file}.*}")]).any?
           options[:template] = files.first.squeeze '/'
         else
           Log.warn "render_template: #{file} does not exist in the following directories: #{roots.join(',')}."

data/lib/ramaze/helper/redirect.rb

@@ -59,7 +59,7 @@ module Ramaze
     def raw_redirect(target, opts = {})
       target = target.to_s
       header = {'Location' => target}
-      status = opts[:status] || STATUS_CODE["Moved Temporarily"]
+      status = opts[:status] || 302 # Found
       body = %{You are being redirected, please follow <a href="#{target}">this link to: #{target}</a>!}
 
       Log.info("Redirect to '#{target}'")
@@ -72,10 +72,28 @@ module Ramaze
       request[:redirected]
     end
 
-    # redirect to the location the browser says it's coming from.
+    # Redirect to the location the browser says it's coming from.
+    # If the current address is the same as the referrer or no referrer exists
+    # yet, we will redirect to +fallback+.
+    #
+    # NOTE:
+    #   * In some cases this may result in a double redirect, given that the
+    #     request query parameters may change order. We don't have a nice way
+    #     of handling that yet, but it should be very, very rare
+
+    def redirect_referer(fallback = R(:/))
+      if referer = request.referer and url = request.url
+        referer_uri = URI(referer)
+        request_uri = URI(url)
 
-    def redirect_referer
-      redirect request.referer
+        if referer_uri == request_uri
+          redirect fallback
+        else
+          redirect referer
+        end
+      else
+        redirect fallback
+      end
     end
     alias redirect_referrer redirect_referer
   end

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/helper.rb

@@ -12,8 +12,9 @@ module Ramaze
   module Helper
     LOOKUP = Set.new
     PATH = ['']
+    path = File.expand_path("#{BASEDIR}/../spec/ramaze/helper/")
     trait :ignore => [
-      /#{Regexp.escape(File.expand_path(BASEDIR/'../spec/ramaze/helper/'))}\//
+      /#{Regexp.escape(path)}\//
     ]
 
     module Methods
@@ -44,7 +45,7 @@ module Ramaze
             if require_helper(name)
               redo
             else
-              raise LoadError, "#{name} not found"
+              raise LoadError, "helper #{name} not found"
             end
           end
         end
@@ -52,6 +53,8 @@ module Ramaze
 
       private
 
+      # returns the Ramaze::Helper::Name Module Constant if exists.
+
       def find_helper(name)
         name = name.to_s.camel_case
         ramaze_helper_consts = ::Ramaze::Helper.constants.grep(/^#{name}$/i)
@@ -60,16 +63,21 @@ module Ramaze
         end
       end
 
+      # Loads helper from /lib/ramaze/helper/name.(so, bundle, rb)
+      # raises LoadError if helper not found.
+
       def require_helper(name)
-        paths = (PATH + [Global.root, BASEDIR/:ramaze]).join(',')
+        paths = (PATH + [Global.root, "#{BASEDIR}/ramaze"]).join(',')
         glob = "{#{paths}}/helper/#{name}.{so,bundle,rb}"
         files = Dir[glob]
         ignore = Helper.trait[:ignore]
         files.reject!{|f| ignore.any?{|i| f =~ i }}
-        raise LoadError, "#{name} not found" unless file = files.first
+        raise LoadError, "file for #{name} not found" unless file = files.first
         require(file)
       end
 
+      # injects the helper via include and extend, takes Constant as argument.
+
       def use_helper(mod)
         include mod
         extend mod

data/lib/ramaze/log/rotatinginformer.rb

@@ -0,0 +1,168 @@
+module Ramaze
+  
+  module Logger
+
+    # A customized logger (based on Informer) that creates multiple log files based on time
+
+    class RotatingInformer
+      
+      include Logging
+
+      attr_accessor :time_format, :log_levels
+      attr_reader :base_dir
+      
+      # parameter for Time.now.strftime
+      trait :timestamp => "%Y-%m-%d %H:%M:%S"
+
+      # This is how the final output is arranged.
+      trait :format => "[%time] %prefix  %text"
+
+      # Create a new instance of RotatingInformer.
+      #
+      # base_dir is the directory where all log files will be stored
+      #
+      # time_format is the time format used to name the log files.
+      # Possible formats are identical to those
+      # accepted by Time.strftime
+      #
+      # log_levelse is an array describing what kind of messages
+      # that the log receives. The array may contain
+      # any or all of the symbols :debug, :error, :info and/or :warn
+      #
+      # Examples:
+      #   RotatingInformer.new('logs')
+      #                                   #=> Creates logs in directory called logs.
+      #                                       The generated filenames will be in the
+      #                                       form YYYY-MM-DD.log
+      #   RotatingInformer.new('logs', '%Y-%m.txt')
+      #                                   #=> Creates logs in directory called logs.
+      #                                       The generated filenames will be in the
+      #                                       form YYYY-MM.txt
+      #   RotatingInformer.new('logs', '%Y-%m.txt', [:error])
+      #                                   #=> Creates logs in directory called logs.
+      #                                       The generated filenames will be in the
+      #                                       form YYYY-MM.txt. Only errors will be
+      #                                       logged to the files.
+
+      def initialize(base_dir, time_format = '%Y-%m-%d.log', log_levels = [:debug, :error, :info, :warn])
+        # Verify and set base directory
+        send :base_dir=, base_dir, true
+        
+        @time_format = time_format
+        @log_levels = log_levels
+        
+        # Keep track of log shutdown (to prevent StackErrors due to recursion)
+        @in_shutdown = false
+      end
+
+      # Set the base directory for log files
+      # 
+      # If this method is called with the raise_exception
+      # parameter set to true the method will raise an exception
+      # if the specified directory does not exist or is unwritable.
+      # 
+      # If raise_exception is set to false, the method will just
+      # silently fail if the specified directory does not exist
+      # or is unwritable
+      
+      def base_dir=(directory, raise_exception = false)
+        # Expand directory path
+        base_dir = File.expand_path(directory)
+        # Verify that directory path exists
+        if File.exist?(base_dir)
+          # Verify that directory path is a directory
+          if File.directory?(base_dir)
+            # Verify that directory path is writable
+            if File.writable?(base_dir)
+              @base_dir = base_dir
+            else
+              raise Exception.new("#{base_dir} is not writable") if raise_exception
+            end
+          else
+            raise Exception.new("#{base_dir} is not a directory") if raise_exception
+          end
+        else
+          raise Exception.new("#{base_dir} does not exist.") if raise_exception
+        end
+      end
+      
+      # Close the file we log to if it isn't closed already.
+
+      def shutdown
+        if @out.respond_to?(:close)
+          unless @in_shutdown
+            @in_shutdown = true
+            Log.debug("close, #{@out.inspect}")
+            @in_shutdown = false
+          end
+          @out.close
+        end
+      end
+
+      # Integration to Logging.
+
+      def log tag, *messages
+
+        return unless @log_levels.include?(tag)
+
+        # Update current log
+        update_current_log       
+
+        messages.flatten!
+
+        prefix = tag.to_s.upcase.ljust(5)
+
+        messages.each do |message|
+          @out.puts(log_interpolate(prefix, message))
+        end
+
+        @out.flush if @out.respond_to?(:flush)
+      end
+
+      # Takes the prefix (tag), text and timestamp and applies it to
+      # the :format trait.
+
+      def log_interpolate prefix, text, time = timestamp
+        message = class_trait[:format].dup
+
+        vars = { '%time' => time, '%prefix' => prefix, '%text' => text }
+        vars.each{|from, to| message.gsub!(from, to) }
+
+        message
+      end
+
+      # This uses Global.inform_timestamp or a date in the format of
+      #   %Y-%m-%d %H:%M:%S
+      #   # => "2007-01-19 21:09:32"
+
+      def timestamp
+        mask = class_trait[:timestamp]
+        Time.now.strftime(mask || "%Y-%m-%d %H:%M:%S")
+      end
+
+      # is @out closed?
+
+      def closed?
+        @out.respond_to?(:closed?) && @out.closed?
+      end
+
+      private
+
+      # Checks whether current filename is still valid.
+      # If not, update the current log to point at the new
+      # filename
+
+      def update_current_log
+        out = File.join(@base_dir, Time.now.strftime(@time_format))
+        if @out.nil? || @out.path != out
+          # Close old log if necessary
+          shutdown unless @out.nil? || closed?
+
+          # Start new log
+          @out = File.open(out, 'ab+')
+        end
+      end
+    end
+
+  end
+end

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/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

@@ -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/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/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)