Pistos-ramaze 2008.09

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

@@ -0,0 +1,97 @@
+#          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
+
+  # Ramaze support simple routing using string, regex and lambda based routers.
+  # Route are stored in a dictionary, which supports hash-like access but
+  # preserves order, so routes are evaluated in the order they are added.
+  #
+  # String routers are the simplest way to route in Ramaze. One path is
+  # translated into another:
+  #
+  #   Ramaze::Route[ '/foo' ] = '/bar'
+  #     '/foo'  =>  '/bar'
+  #
+  # Regex routers allow matching against paths using regex. Matches within
+  # your regex using () are substituted in the new path using printf-like
+  # syntax.
+  #
+  #   Ramaze::Route[ %r!^/(\d+)\.te?xt$! ] = "/text/%d"
+  #     '/123.txt'  =>  '/text/123'
+  #     '/789.text' =>  '/text/789'
+  #
+  # For more complex routing, lambda routers can be used. Lambda routers are
+  # passed in the current path and request object, and must return either a new
+  # path string, or nil.
+  #
+  #   Ramaze::Route[ 'name of route' ] = lambda{ |path, request|
+  #     '/bar' if path == '/foo' and request[:bar] == '1'
+  #   }
+  #     '/foo'        =>  '/foo'
+  #     '/foo?bar=1'  =>  '/bar'
+  #
+  # Lambda routers can also use this alternative syntax:
+  #
+  #   Ramaze::Route('name of route') do |path, request|
+  #     '/bar' if path == '/foo' and request[:bar] == '1'
+  #   end
+
+  class Route
+    trait[:routes] ||= Dictionary.new
+
+    class << self
+      # Retrieve key from trait
+      def [](key)
+        trait[:routes][key]
+      end
+
+      # Set key to value in trait
+      def []=(key, value)
+        trait[:routes][key] = value
+      end
+
+      # remove all routes
+      def clear
+        trait[:routes].clear
+      end
+
+      # Resolve path according to routes.
+      def resolve(path)
+        trait[:routes].each do |key, val|
+          if key.is_a?(Regexp)
+            if md = path.match(key)
+              return val % md.to_a[1..-1]
+            end
+
+          elsif val.respond_to?(:call)
+            if new_path = val.call(path, Request.current)
+              return new_path
+            end
+
+          elsif val.is_a?(String)
+            return val if path == key
+
+          else
+            Log.error "Invalid route #{key} => #{val}"
+          end
+        end
+
+        nil
+      end
+    end
+  end
+
+  class Rewrite < Route
+    trait[:routes] ||= Dictionary.new
+  end
+
+  # Shortcut for defining new routes.
+  def self.Route(name, value = nil, &block)
+    Route[name] = value || block
+  end
+
+  def self.Rewrite(name, value = nil, &block)
+    Rewrite[name] = value || block
+  end
+end

data/lib/ramaze/setup.rb

@@ -0,0 +1,50 @@
+module Ramaze
+  def self.setup(start = true, &block)
+    SetupEnvironment.new(&block) if block_given?
+    self.start if start
+  end
+
+  class SetupEnvironment
+    # FIXME:
+    # * This is weird, class scope includes Global, yet it's skipped
+    #   by Ruby on the lookup only because it's not in the scope of the block
+    #   at the point of creation, shouldn't instance_eval take the binding of
+    #   the SetupEnvironment instance in acocunt?
+
+    def initialize(&block)
+      instance_eval(&block)
+    end
+
+    # Shortcut for Ramaze::Gems::gem
+    def gem(*args)
+      require 'ramaze/contrib/gems'
+      Ramaze::Gems::gem(*args)
+      Ramaze::Gems::setup
+    end
+
+    # Shortcut if you don't need specific versions but tons of gems
+    def gems(*args)
+      args.each{|g| gem(g) }
+    end
+
+    def global(hash = nil)
+      if hash
+        Global.merge!(hash)
+      else
+        Global
+      end
+    end
+    alias option global
+  end
+end
+
+__END__
+Usage example:
+
+Ramaze.setup do
+  gem 'json'
+
+  option :middleware => true
+  global.adapter = :thin
+  option.port = 7000
+end

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

@@ -0,0 +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.
+
+module Ramaze
+  module CoreExtensions
+
+    # Extensions for Array
+
+    module Array
+
+      #   a = [1, 2, 3]
+      #   a.put_within(4, :after => 2, :before => 3)
+      #   a # => [1, 2, 4, 3]
+
+      def put_within(object, constrain)
+        pre, post = constrain.values_at(:after, :before)
+
+        return put_after(pre, object) if rindex(post) - index(pre) == 1
+
+        raise ArgumentError, "Too many elements within constrain"
+      end
+
+      #   a = [1, 2, 3]
+      #   a.put_after(2, 4)
+      #   a # => [1, 2, 4, 3]
+
+      def put_after(element, object)
+        return self[index(element) + 1, 0] = object if include?(element)
+
+        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

@@ -0,0 +1,25 @@
+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/blankslate.rb

@@ -0,0 +1,7 @@
+unless defined?(BlankSlate)
+  class BlankSlate < BasicObject; end if defined?(BasicObject)
+
+  class BlankSlate
+    instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+  end
+end