ramaze 2008.06 → 2008.11

data/lib/ramaze/option/holder.rb

@@ -95,16 +95,6 @@ module Ramaze
         ].find{|path| File.directory?(path) } || @view_root
       end
 
-      def template_root=(tr)
-        Ramaze::deprecated "Global.template_root=", "Global.view_root="
-        self.view_root = tr
-      end
-
-      def template_root
-        Ramaze::deprecated "Global.template_root", "Global.view_root"
-        self.view_root
-      end
-
       def adapter
         find_from_aliases(@adapter, :adapter_aliases, Ramaze::Adapter, "ramaze/adapter")
       end
@@ -114,17 +104,7 @@ module Ramaze
       end
 
       def sourcereload=(interval)
-        if interval
-          if interval.is_a?(Numeric)
-            @sourcereload = interval
-            Ramaze::SourceReload.restart
-          else
-            Log.warn("sourcereload= %p not Numeric, ignoring." % interval)
-          end
-        else
-          @sourcereload = interval
-          Ramaze::SourceReload.shutdown
-        end
+        Ramaze::Reloader::OPTIONS[:cooldown] = interval
       end
 
       private
@@ -133,17 +113,15 @@ module Ramaze
         case name
         when String, Symbol
           name = name.to_s
-          name = self[alias_key][name] || name
-          find_require(name, mod, path)
+          class_name = self[alias_key][name] || name
+          find_require(name, class_name, mod, path)
         else
           name
         end
       end
 
-      def find_require(name, mod, path)
-        class_name = name.to_s
-        file_path = File.join(path, class_name.downcase)
-
+      def find_require(name, class_name, mod, path)
+        file_path = File.join(path, name)
         require(file_path) unless mod.const_defined?(class_name)
 
         mod.const_get(class_name)

data/lib/ramaze/reloader.rb

@@ -0,0 +1,186 @@
+#          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
+
+  # High performant source reloader
+  #
+  # This class acts as Rack middleware.
+  #
+  # It does not depend on Ramaze itself, but you might have to adjust the
+  # 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).
+  #
+  # Please note that this will not reload files in the background, it does so
+  # only when actively called
+  # In case of Ramaze it is performing a check/reload cycle at the start of
+  # every request, but also respects a cool down time, during which nothing will
+  # be done.
+  #
+  # After every reload the OPTIONS hash will be checked for changed options and
+  # assigned to the instance, so you may change options during the lifetime of
+  # your application.
+  #
+  # A number of hooks will be executed during the reload cycle, see
+  # Ramaze::ReloaderHooks for more information.
+
+  class Reloader
+    OPTIONS = {
+      # At most check every n seconds
+      # nil/false will never trigger the reload cycle
+      # 0 will cycle on every call
+      :cooldown => 2,
+
+      # Compiled files cannot be reloaded during runtime
+      :ignore => /\.so$/,
+
+      # Run cycle in a Thread.exclusive, by default no threads are used.
+      :thread => false,
+
+      # If you assign a block here it will be instance_evaled instead of
+      # calling cycle. This allows you to use for example EventMachine for
+      # well performing asynchronous cycling.
+      :control => nil, # lambda{ cycle },
+    }
+
+    def initialize(app)
+      @app = app
+      @last = Time.now
+      @mtimes = {}
+      @cache = {}
+      options_reload
+    end
+
+    def options_reload
+      @cooldown, @ignore, @control, @thread =
+        OPTIONS.values_at(:cooldown, :ignore, :control, :thread)
+    end
+
+    def call(env)
+      options_reload
+
+      if @cooldown and Time.now > @last + @cooldown
+        if @control
+          instance_eval(&@control)
+        elsif @thread
+          Thread.exclusive{ cycle }
+        else
+          cycle
+        end
+
+        @last = Time.now
+      end
+
+      @app.call(env)
+    end
+
+    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
+
+      after_cycle
+    end
+
+    # A safe Kernel::load, issuing the hooks depending on the results
+    def safe_load(file)
+      before_safe_load(file)
+      load(file)
+      after_safe_load_succeed(file)
+    rescue Object => ex
+      Log.error(ex)
+      after_safe_load_failed(file, ex)
+    end
+
+    def rotation
+      files = [$0, __FILE__, *$LOADED_FEATURES].uniq
+      paths = ['./', *$LOAD_PATH].uniq
+
+      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}
+        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 $" ?
+      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
+      end
+
+      return nil
+    end
+
+
+    # Holds hooks that are called before and after #cycle and #safe_load
+    module Hooks
+      # Overwrite to add actions before the reload rotation is started.
+      def before_cycle
+      end
+
+      # Overwrite to add actions after the reload rotation has ended.
+      def after_cycle
+      end
+
+      # Overwrite to add actions before a file is Kernel::load-ed
+      def before_safe_load(file)
+        Log.debug("reload #{file}")
+      end
+
+      # Overwrite to add actions after a file is Kernel::load-ed successfully,
+      # by default we clean the Cache for compiled templates and resolved actions.
+      def after_safe_load_succeed(file)
+        Ramaze::Cache.compiled.clear
+        Ramaze::Cache.resolved.clear
+        Ramaze::Cache.action_methods.clear
+        after_safe_load(file)
+      end
+
+      # Overwrite to add custom hook in addition to default Cache cleaning
+      def after_safe_load(file)
+      end
+
+      # Overwrite to add actions after a file is Kernel::load-ed unsuccessfully,
+      # by default we output an error-message with the exception.
+      def after_safe_load_failed(file, error)
+        Log.error(error)
+      end
+    end
+
+    include Hooks
+
+  end
+end

data/lib/ramaze/setup.rb

@@ -24,7 +24,7 @@ module Ramaze
 
     # Shortcut if you don't need specific versions but tons of gems
     def gems(*args)
-      gems.each{|g| gem(g) }
+      args.each{|g| gem(g) }
     end
 
     def global(hash = nil)

data/lib/ramaze/snippets.rb

@@ -7,3 +7,16 @@ glob = File.join(dir, '**', '*.rb')
 Dir[glob].each do |snippet|
   require(snippet)
 end
+
+Ramaze::CoreExtensions.constants.each do |const|
+  ext = Ramaze::CoreExtensions.const_get(const)
+  into = Module.const_get(const)
+
+  collisions = ext.instance_methods & into.instance_methods
+
+  if collisions.empty?
+    into.__send__(:include, ext)
+  else
+    warn "Won't include %p with %p, %p exists" % [into, ext, collisions]
+  end
+end

data/lib/ramaze/snippets/array/put_within.rb

@@ -1,37 +1,44 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-class Array
+module Ramaze
+  module CoreExtensions
 
-  #   a = [1, 2, 3]
-  #   a.put_within(4, :after => 2, :before => 3)
-  #   a # => [1, 2, 4, 3]
+    # Extensions for Array
 
-  def put_within(object, constrain)
-    pre, post = constrain.values_at(:after, :before)
+    module Array
 
-    unless rindex(post) - index(pre) == 1
-      raise ArgumentError, "Too many elements within constrain"
-    end
+      #   a = [1, 2, 3]
+      #   a.put_within(4, :after => 2, :before => 3)
+      #   a # => [1, 2, 4, 3]
 
-    put_after(pre, object)
-  end
+      def put_within(object, constrain)
+        pre, post = constrain.values_at(:after, :before)
 
-  #   a = [1, 2, 3]
-  #   a.put_after(2, 4)
-  #   a # => [1, 2, 4, 3]
+        return put_after(pre, object) if rindex(post) - index(pre) == 1
 
-  def put_after(element, object)
-    raise ArgumentError, "The given element doesn't exist" unless include?(element)
-    self[index(element) + 1, 0] = object
-  end
+        raise ArgumentError, "Too many elements within constrain"
+      end
+
+      #   a = [1, 2, 3]
+      #   a.put_after(2, 4)
+      #   a # => [1, 2, 4, 3]
 
-  #   a = [1, 2, 3]
-  #   a.put_before(2, 4)
-  #   a # => [1, 4, 2, 3]
+      def put_after(element, object)
+        return self[index(element) + 1, 0] = object if include?(element)
 
-  def put_before(element, object)
-    raise ArgumentError, "The given element doesn't exist" unless include?(element)
-    self[rindex(element), 0] = object
+        raise ArgumentError, "The given element doesn't exist"
+      end
+
+      #   a = [1, 2, 3]
+      #   a.put_before(2, 4)
+      #   a # => [1, 4, 2, 3]
+
+      def put_before(element, object)
+        return self[rindex(element), 0] = object if include?(element)
+
+        raise ArgumentError, "The given element doesn't exist"
+      end
+    end
   end
 end

data/lib/ramaze/snippets/binding/locals.rb

@@ -1,13 +1,25 @@
-class Binding
-
-  # returns a hash of localvar/localvar-values from binding, useful for
-  # template engines that do not accept bindings and force passing locals via
-  # hash
-  #   usage: x = 42; p binding.locals #=> {'x'=> 42}
-  def locals
-    Kernel::eval '
-      local_variables.inject({}){|h,v| h.update v => eval(v)}
-    ', self
-  end
+module Ramaze
+  module CoreExtensions
+
+    # Extensions for Binding
+
+    module Binding
 
+      # Returns a hash of localvar/localvar-values from binding, useful for
+      # template engines that do not accept bindings and force passing locals
+      # via hash
+      #
+      # Usage:
+      #   x = 42; p binding.locals #=> {'x'=> 42}
+
+      def locals
+        ::Kernel::eval '
+        local_variables.inject({}){|h,v|
+          k = v.to_s
+          h.merge!(k => eval(k))
+        }', self
+      end
+
+    end
+  end
 end

data/lib/ramaze/snippets/dictionary.rb

@@ -362,7 +362,7 @@ module Ramaze
       reorder
       self
     end
-    alias :merge! update
+    alias merge! update
 
     def merge( hsh2 )
       self.dup.update(hsh2)
@@ -390,7 +390,7 @@ module Ramaze
     def length
       @order.length
     end
-    alias :size :length
+    alias size length
 
     def empty?
       @hash.empty?

data/lib/ramaze/snippets/fiber.rb

@@ -0,0 +1,63 @@
+unless defined? Fiber
+  require 'thread'
+
+  class FiberError < StandardError; end
+
+  class Fiber
+    def initialize
+      raise ArgumentError, 'new Fiber requires a block' unless block_given?
+
+      @yield = Queue.new
+      @resume = Queue.new
+
+      @thread = Thread.new{ @yield.push [*yield(*wait)] }
+      @thread.abort_on_exception = true
+      @thread[:fiber] = self
+    end
+    attr_reader :yield, :thread
+
+    def resume *args
+      raise FiberError, 'dead fiber called' unless @thread.alive?
+      @resume.push(args)
+      result = @yield.pop
+      result.size > 1 ? result : result.first
+    end
+
+    def wait
+      @resume.pop
+    end
+    
+    def self.yield *args
+      raise FiberError, "can't yield from root fiber" unless fiber = Thread.current[:fiber]
+      fiber.yield.push(args)
+      result = fiber.wait
+      result.size > 1 ? result : result.first
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}>"
+    end
+  end
+end
+
+if __FILE__ == $0
+  f = Fiber.new{ puts 'hi'; p Fiber.yield(1); puts 'bye'; :done }
+  p f.resume
+  p f.resume(2)
+end
+
+__END__
+
+$ ruby fbr.rb 
+hi
+1
+2
+bye
+:done
+
+$ ruby1.9 fbr.rb 
+hi
+1
+2
+bye
+:done