manveru-ramaze 2008.07 → 2008.08

data/lib/ramaze/option.rb

@@ -75,7 +75,7 @@ module Ramaze
     o "Instruction for daemonize, only works with bin/ramaze for now",
       :daemonize, 'start', :cli => [:start, :stop]
 
-    o "Turn on customized error pages.",
+    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",
@@ -103,7 +103,7 @@ module Ramaze
       :mapping, {}
 
     o "Activate middleware",
-      :middleware, false
+      :middleware, true
 
     o "For your own modes to decide on",
       :mode, :live, :cli => [:live, :dev]
@@ -144,7 +144,7 @@ module Ramaze
     o "What signal to trap to call Ramaze::shutdown",
       :shutdown_trap, "SIGINT"
 
-    o "Interval in seconds of the background SourceReload",
+    o "Interval in seconds of the Reloader",
       :sourcereload, 3, :cli => 3
 
     o "Test before start if adapters will be able to connect",

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, *$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
+          Log::warn "Couldn't figure 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/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

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

@@ -3,54 +3,54 @@ class Numeric
   def seconds
     self
   end
-  alias :second :seconds
+  alias second seconds
 
   # 60 seconds in a minute
   def minutes
     self * 60
   end
-  alias :minute :minutes
+  alias minute minutes
 
   # 60 minutes in an hour
   def hours
     self * 3600
   end
-  alias :hour :hours
+  alias hour hours
 
   # 24 hours in a day
   def days
     self * 86400
   end
-  alias :day :days
+  alias day days
 
   # 7 days in a week
   def weeks
     self * 604800
   end
-  alias :week :weeks
+  alias week weeks
 
   # 30 days in a month
   def months
     self * 2592000
   end
-  alias :month :months
+  alias month months
 
   # 365.25 days in a year
   def years
     self * 883612800
   end
-  alias :year :years
+  alias year years
 
   # Time in the past, i.e. 3.days.ago
   def ago t = Time.now
     t - self
   end
-  alias :before :ago
+  alias before ago
 
   # Time in the future, i.e. 3.days.from_now
   def from_now t = Time.now
     t + self
   end
-  alias :since :from_now
+  alias since from_now
 
-end unless 5.respond_to? :days
+end unless 5.respond_to? :days

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

@@ -1,5 +1,7 @@
 module Ramaze
-  DEPRECATED_CONSTANTS = {}
+  DEPRECATED_CONSTANTS = {
+    :ThreadAccessor => :StateAccessor
+  }
 
   def self.deprecated(from, to = nil)
     message = "%s is deprecated"
@@ -10,7 +12,7 @@ module Ramaze
   def self.const_missing(name)
     if to = DEPRECATED_CONSTANTS[name]
       Log.warn "Ramaze::#{name} is deprecated, use #{to} instead"
-      to
+      constant(to)
     else
       super
     end

data/lib/ramaze/snippets/ramaze/fiber.rb

@@ -0,0 +1,24 @@
+module Ramaze
+  class Fiber < ::Fiber
+    # initialize isn't being called, so we have to hook into ::new
+    def self.new(*args)
+      instance = super
+      instance.state = {}
+      instance
+    end
+
+    attr_accessor :state
+
+    def [](key)
+      @state[key]
+    end
+
+    def []=(key, value)
+      @state[key] = value
+    end
+
+    def key?(key)
+      @state.key?(key)
+    end
+  end if defined?(::Fiber)
+end

data/lib/ramaze/snippets/ramaze/state.rb

@@ -0,0 +1,86 @@
+module Ramaze
+  class State
+    def initialize
+      @core = detect
+    end
+
+    def detect
+      require 'fiber'
+      @extract = :resume
+      Ramaze::Fiber
+    rescue LoadError
+      @extract = :value
+      ::Thread
+    end
+
+    def [](key)
+      @core.current[key]
+    end
+
+    def []=(key, value)
+      @core.current[key] = value
+    end
+
+    def key?(key)
+      @core.current.key?(key)
+    end
+
+    def wrap(&block)
+      @core.new(&block).send(@extract)
+    end
+  end
+
+  module StateAccessor
+
+    # Iterate over the names and yield accordingly.
+    # names are either objects responding to #to_sym or hashes.
+    #
+    # It's only used within this module for abstractin-purposes.
+    # Usage below.
+    def self.each(*names)
+      names.each do |name|
+        if name.respond_to?(:to_hash)
+          name.to_hash.each do |key, meth|
+            key, meth = key.to_sym, meth.to_sym
+            yield key, meth
+          end
+        else
+          key = meth = name.to_sym
+          yield key, meth
+        end
+      end
+    end
+
+    # state_writer and state_reader, initializer is a block that may be given
+    # and its result will be the new value in case the reader was never called
+    # before or the value wasn't set before.
+    def state_accessor(*names, &initializer)
+      state_writer(*names)
+      state_reader(*names, &initializer)
+    end
+
+    # Simple writer accessor to STATE[key]=
+    def state_writer(*names)
+      StateAccessor.each(*names) do |key, meth|
+        define_method("#{meth}="){|obj| STATE[key] = obj }
+      end
+    end
+
+    # Reader accessor for STATE[key]
+    def state_reader(*names, &initializer)
+      StateAccessor.each(*names) do |key, meth|
+        if initializer
+          define_method(meth) do
+            unless STATE.key?(key)
+              STATE[key] = instance_eval(&initializer)
+            else
+              STATE[key]
+            end
+          end
+        else
+          define_method(meth){ STATE[key] }
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/sourcereload.rb

@@ -2,6 +2,7 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
+  Reloader::OPTIONS[:cooldown] = nil
 
   # SourceReload provides a way to reload changed files automatically during
   # runtime. Its default behaviour in Ramaze is to check periodically for

data/lib/ramaze/template/maruku.rb

@@ -0,0 +1,34 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'maruku'
+
+module Ramaze
+  module Template
+
+    # Is responsible for compiling a template using the Ezamar templating engine.
+
+    class Maruku < Template
+
+      ENGINES[self] = %w[ mkd ]
+
+      class << self
+
+        # Transforms an action into the XHTML code for parsing and returns
+        # the result
+        def transform(action)
+          maruku = wrap_compile(action)
+          maruku.to_html
+        end
+
+        # Compile a template, applying all transformations from the pipeline
+        # and returning an instance of ::Ezamar::Template
+
+        def compile(action, template)
+          ::Maruku.new(template)
+        end
+      end
+    end
+  end
+end
+

data/lib/ramaze/template.rb

@@ -16,7 +16,10 @@ module Ramaze
 
     ENGINES = {} unless defined?(ENGINES)
 
-    AVAILABLE_ENGINES = %w[ Amrita2 Builder Erubis Haml Liquid Markaby Nagoro None RedCloth Remarkably Sass XSLT Tenjin Tagz ]
+    AVAILABLE_ENGINES = %w[
+      Amrita2 Builder Erubis Haml Liquid Markaby Maruku Nagoro None RedCloth
+      Remarkably Sass Tagz Tenjin XSLT
+    ]
 
     AVAILABLE_ENGINES.each do |const|
       autoload(const, "ramaze/template/#{const.downcase}")

data/lib/ramaze/tool/mime.rb

@@ -15,10 +15,20 @@ module Ramaze
 
         # Get MIME-type for the given filename based on extension.
         # Answers with an empty string if none is found.
-        def type_for file
+        def type_for(file)
           ext = File.extname(file)
           trait[:types][ext].to_s
         end
+
+        def ext_for(mime)
+          exts = []
+
+          trait[:types].each do |ext, mime_type|
+            exts << ext if mime == mime_type
+          end
+
+          exts.sort_by{|e| e.size }.first
+        end
       end
     end
   end

data/lib/ramaze/trinity.rb

@@ -2,12 +2,15 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
+  STATE = State.new
 
   # The module to be included into the Controller it basically just provides
   # #request, #response and #session, each accessing Thread.current to
   # retrieve the demanded object
 
   module Trinity
-    thread_accessor :request, :response, :session
+    extend StateAccessor
+
+    state_accessor :request, :response, :session
   end
 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.06"
+  VERSION = "2008.08"
 end

data/lib/ramaze.rb

@@ -39,7 +39,7 @@ Thread.abort_on_exception = true
 
 # Bootstrap
 require 'ramaze/version'
-require 'ramaze/sourcereload'
+require 'ramaze/reloader'
 require 'ramaze/snippets'
 require 'ramaze/log'
 require 'ramaze/trinity'
@@ -63,7 +63,7 @@ module Ramaze
   # Each of these classes will be called ::startup upon Ramaze.startup
 
   trait :essentials => [
-    Global, Cache, Contrib, Controller, Session, SourceReload, Adapter
+    Global, Cache, Contrib, Controller, Session, Adapter
   ]
 
   trait :started => false

data/rake_tasks/gem.rake

@@ -65,3 +65,9 @@ end
 
   File.open("ramaze.gemspec", 'w+'){|file| file.puts(gemspec) }
 end
+
+spec = generate_gemspec(version_today)
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end