ramaze 0.3.5 → 0.3.9

data/lib/ramaze/route.rb

@@ -1,43 +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.
 
-# 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
-
 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
+    trait[:routes] ||= Dictionary.new
 
     class << self
       def [](key)
@@ -47,10 +48,37 @@ module Ramaze
       def []=(key, value)
         trait[:routes][key] = value
       end
+
+      def clear
+        trait[:routes].clear
+      end
+
+      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
 
   def self.Route(name, &block)
     Route[name] = block
   end
-end
+end

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

@@ -2,6 +2,11 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 class 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)
 
@@ -12,11 +17,19 @@ class Array
     put_after(pre, object)
   end
 
+  #   a = [1, 2, 3]
+  #   a.put_after(2, 4)
+  #   a # => [1, 2, 4, 3]
+
   def put_after(element, object)
     raise ArgumentError, "The given element doesn't exist" unless include?(element)
     self[index(element) + 1, 0] = object
   end
 
+  #   a = [1, 2, 3]
+  #   a.put_before(2, 4)
+  #   a # => [1, 4, 2, 3]
+
   def put_before(element, object)
     raise ArgumentError, "The given element doesn't exist" unless include?(element)
     self[rindex(element), 0] = object

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

@@ -0,0 +1,13 @@
+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
+    eval '
+      local_variables.inject({}){|h,v| h.update v => eval(v)}
+    ', self
+  end
+
+end

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

@@ -4,15 +4,17 @@
 # Extensions for Kernel
 
 module Kernel
-  # This is similar to +__FILE__+ and +__LINE__+, and returns a String
-  # representing the directory of the current file is.
-  # Unlike +__FILE__+ the path returned is absolute.
-  #
-  # This method is convenience for the
-  #  File.expand_path(File.dirname(__FILE__))
-  # idiom.
-  #
   unless defined?__DIR__
+
+    # This is similar to +__FILE__+ and +__LINE__+, and returns a String
+    # representing the directory of the current file is.
+    # Unlike +__FILE__+ the path returned is absolute.
+    #
+    # This method is convenience for the
+    #  File.expand_path(File.dirname(__FILE__))
+    # idiom.
+    #
+
     def __DIR__()
       filename = caller[0][/(.*?):/, 1]
       File.expand_path(File.dirname(filename))

data/lib/ramaze/snippets/kernel/aquire.rb

@@ -1 +1 @@
-require File.join(File.dirname(__FILE__), 'acquire')
+require(File.join(File.dirname(__FILE__), 'acquire'))

data/lib/ramaze/snippets/kernel/constant.rb

@@ -17,7 +17,7 @@ module Kernel
   #   require 'test/unit'
   #   Test.constant("Unit::Assertions")   # -> Test::Unit::Assertions
   #   Test.constant("::Test::Unit")       # -> Test::Unit
-  #
+
   def constant(const)
     const = const.to_s.dup
     base = const.sub!(/^::/, '') ? Object : ( self.kind_of?(Module) ? self : self.class )

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

@@ -0,0 +1,6 @@
+class Object
+  def pretty s = ''
+    PP.pp(self, s)
+    s
+  end
+end

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

@@ -0,0 +1,11 @@
+class Object
+
+  # returns a new clean binding for this object
+  #   usage: eval 'self', object.scope  #=> returns object 
+  #
+
+  def scope
+    lambda{}
+  end
+
+end

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

@@ -0,0 +1,5 @@
+require(File.join(File.dirname(__FILE__), '../ramaze/thread_accessor'))
+
+class Object
+  include Ramaze::ThreadAccessor
+end

data/lib/ramaze/snippets/ordered_set.rb

@@ -1,7 +1,7 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-require File.join(File.dirname(__FILE__), 'blankslate')
+require(File.join(File.dirname(__FILE__), 'blankslate'))
 
 class OrderedSet < BlankSlate
   def initialize(*args)

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

@@ -0,0 +1,11 @@
+class Proc
+
+  # returns a hash of localvar/localvar-values from proc, useful for template
+  # engines that do not accept bindings/proc and force passing locals via
+  # hash
+  #   usage: x = 42; p Proc.new.locals #=> {'x'=> 42}
+  def locals
+    instance_eval('binding').locals
+  end
+
+end

data/lib/ramaze/snippets/ramaze/thread_accessor.rb

@@ -0,0 +1,44 @@
+module Ramaze
+  module ThreadAccessor
+    def ThreadAccessor.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
+
+    def thread_accessor(*names, &initializer)
+      thread_writer(*names)
+      thread_reader(*names, &initializer)
+    end
+
+    def thread_writer(*names)
+      ThreadAccessor.each(*names) do |key, meth|
+        define_method("#{meth}="){|obj| Thread.current[key] = obj }
+      end
+    end
+
+    def thread_reader(*names, &initializer)
+      ThreadAccessor.each(*names) do |key, meth|
+        if initializer
+          define_method(meth) do
+            unless Thread.current.key?(key)
+              Thread.current[key] = instance_eval(&initializer)
+            else
+              Thread.current[key]
+            end
+          end
+        else
+          define_method(meth){ Thread.current[key] }
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/snippets/string/esc.rb

@@ -0,0 +1,29 @@
+require 'cgi'
+require 'uri'
+
+class String
+
+  # String#escape is an extensible escaping mechanism for string.  currently
+  # it suports
+  #   '<div>foo bar</div>'.esc(:html)
+  #   'foo bar'.esc(:uri)
+  #   'foo bar'.esc(:cgi)
+  #   "foo 'bar'".esc(:sql)
+
+  def escape which = :html
+    case which
+    when :html
+      ::CGI.escapeHTML(self)
+    when :cgi
+      ::CGI.escape(self)
+    when :uri
+      ::URI.escape(self)
+    when :sql  # TODO - leverage DBI or something
+      gsub(%r/'/, "''")
+    else
+      raise ArgumentError, "do not know how to escape '#{ which }'"
+    end
+  end
+
+  alias_method 'esc', 'escape'
+end

data/lib/ramaze/snippets/string/start_with.rb

@@ -0,0 +1,7 @@
+class String
+  unless method_defined?(:start_with?)
+    def start_with?(other)
+      self[0, other.size] == other
+    end
+  end
+end

data/lib/ramaze/snippets/string/unindent.rb

@@ -1,7 +1,12 @@
 class String
   def unindent
-    space = self.split("\n")[1].to_s[/^(\s+)/, 1]
+    space = self.split("\n").find{|l| !l.strip.empty?}.to_s[/^(\s+)/, 1]
     strip.gsub(/^#{space}/, '')
   end
   alias ui unindent
+
+  def unindent!
+    self.replace unindent
+  end
+  alias ui! unindent!
 end

data/lib/ramaze/snippets/struct/values_at.rb

@@ -3,10 +3,6 @@
 
 # Extensions for Struct
 
-class Symbol
-  undef_method :to_int if method_defined?(:to_int)
-end
-
 class Struct
 
   # Example:
@@ -18,7 +14,7 @@ class Struct
   #  # => [15, 10]
 
   def values_at(*keys)
-    if keys.all?{|key| key.respond_to?(:to_int) }
+    if keys.all?{|key| key.respond_to?(:to_int) and not key.is_a?(Symbol) }
       keys.map{|key| values[key.to_int] }
     else
       keys.map{|k| self[k] }

data/lib/ramaze/sourcereload.rb

@@ -1,8 +1,6 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-require 'set'
-
 module Ramaze
 
   # SourceReload provides a way to reload changed files automatically during
@@ -27,7 +25,7 @@ module Ramaze
     # start reloader-thread and assign it to this instance.
 
     def start
-      Inform.dev("initialize automatic source reload every #{interval} seconds")
+      Log.dev("initialize automatic source reload every #{interval} seconds")
       @thread = reloader
     end
 
@@ -60,7 +58,7 @@ module Ramaze
     # Usage example:
     #
     #   trap :HUP do
-    #     Ramaze::Inform.info "reloading source"
+    #     Ramaze::Log.info "reloading source"
     #     Thread.main[:sourcereload].reload
     #   end
     #
@@ -72,7 +70,7 @@ module Ramaze
 
         next if (@mtimes[file] ||= mtime) == mtime
 
-        Inform.debug("reload #{file}")
+        Log.debug("reload #{file}")
         @mtimes[file] = mtime if safe_load(file)
       end
       SourceReloadHooks.after_reload
@@ -83,18 +81,22 @@ module Ramaze
 
     def all_reload_files
       files = Array[$0, *$LOADED_FEATURES]
-      paths = Array['', './', *$LOAD_PATH]
+      paths = Array['./', *$LOAD_PATH]
 
       unless [@files, @paths] == [files, paths]
         @files, @paths = files.dup, paths.dup
 
-        map = files.map do |file|
-          paths.map{|pa|
-            File.expand_path(File.join(pa.to_s, file.to_s))
-          }.find{|po| File.exists?(po) }
-        end
-
-        @map = map.compact
+        @map = files.map{|file|
+          if Pathname.new(file).absolute?
+            file
+          else
+            path = paths.find{|pa|
+              ex = File.expand_path(pa/file)
+              File.exists?(ex)
+            }
+            File.expand_path(path/file) if path
+          end
+        }.compact
       end
 
       @map.grep(class_trait[:reload_glob])
@@ -161,7 +163,7 @@ module Ramaze
     # by default we output an error-message with the exception.
 
     def after_safe_load_failed(file, error)
-      Inform.error(error)
+      Log.error(error)
     end
   end
 end