ptomato-ramaze 2009.02

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

data/lib/ramaze/snippets/dictionary.rb

@@ -0,0 +1,504 @@
+# = dictionary.rb
+#
+# == Copyright (c) 2005 Jan Molic, Thomas Sawyer
+#
+#   Ruby License
+#
+#   This module is free software. You may use, modify, and/or redistribute this
+#   software under the same terms as Ruby.
+#
+#   This program is distributed in the hope that it will be useful, but WITHOUT
+#   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+#   FOR A PARTICULAR PURPOSE.
+#
+# == Special Thanks
+#
+# Ported from OrderHash 2.0, Copyright (c) 2005 jan molic
+#
+# Thanks to Andrew Johnson for his suggestions and fixes of Hash[],
+# merge, to_a, inspect and shift.
+#
+# == Authors & Contributors
+#
+# * Jan Molic
+# * Thomas Sawyer
+
+# Author::    Jan Molic
+# Copyright:: Copyright (c) 2006 Jan Molic
+# License::   Ruby License
+
+# = Dictionary
+#
+# The Dictionary class is a Hash that preserves order.
+# So it has some array-like extensions also. By defualt
+# a Dictionary object preserves insertion order, but any
+# order can be specified including alphabetical key order.
+#
+# == Usage
+#
+# Just require this file and use Dictionary instead of Hash.
+#
+#   # You can do simply
+#   hsh = Dictionary.new
+#   hsh['z'] = 1
+#   hsh['a'] = 2
+#   hsh['c'] = 3
+#   p hsh.keys     #=> ['z','a','c']
+#
+#   # or using Dictionary[] method
+#   hsh = Dictionary['z', 1, 'a', 2, 'c', 3]
+#   p hsh.keys     #=> ['z','a','c']
+#
+#   # but this don't preserve order
+#   hsh = Dictionary['z'=>1, 'a'=>2, 'c'=>3]
+#   p hsh.keys     #=> ['a','c','z']
+#
+#   # Dictionary has useful extensions: push, pop and unshift
+#   p hsh.push('to_end', 15)       #=> true, key added
+#   p hsh.push('to_end', 30)       #=> false, already - nothing happen
+#   p hsh.unshift('to_begin', 50)  #=> true, key added
+#   p hsh.unshift('to_begin', 60)  #=> false, already - nothing happen
+#   p hsh.keys                     #=> ["to_begin", "a", "c", "z", "to_end"]
+#   p hsh.pop                      #=> ["to_end", 15], if nothing remains, return nil
+#   p hsh.keys                     #=> ["to_begin", "a", "c", "z"]
+#   p hsh.shift                    #=> ["to_begin", 30], if nothing remains, return nil
+#
+# == Usage Notes
+#
+# * You can use #order_by to set internal sort order.
+# * #<< takes a two element [k,v] array and inserts.
+# * Use ::auto which creates Dictionay sub-entries as needed.
+# * And ::alpha which creates a new Dictionary sorted by key.
+
+module Ramaze
+  class Dictionary
+
+    class << self
+
+      #--
+      # TODO is this needed? Doesn't the super class do this?
+      #++
+
+      def []( *args )
+        hsh = new
+        if Hash === args[0]
+          hsh.replace(args[0])
+        elsif (args.size % 2) != 0
+          raise ArgumentError, "odd number of elements for Hash"
+        else
+          while !args.empty?
+            hsh[args.shift] = args.shift
+          end
+        end
+        hsh
+      end
+
+      # Like #new but the block sets the order.
+      #
+      def new_by( *args, &blk )
+        new(*args).order_by(&blk)
+      end
+
+      # Alternate to #new which creates a dictionary sorted by key.
+      #
+      #   d = Dictionary.alpha
+      #   d["z"] = 1
+      #   d["y"] = 2
+      #   d["x"] = 3
+      #   d  #=> {"x"=>3,"y"=>2,"z"=>2}
+      #
+      # This is equivalent to:
+      #
+      #   Dictionary.new.order_by { |key,value| key }
+
+      def alpha( *args, &block )
+        new( *args, &block ).order_by_key
+      end
+
+      # Alternate to #new which auto-creates sub-dictionaries as needed.
+      #
+      #   d = Dictionary.auto
+      #   d["a"]["b"]["c"] = "abc"  #=> { "a"=>{"b"=>{"c"=>"abc"}}}
+      #
+      def auto( *args )
+        #AutoDictionary.new(*args)
+        leet = lambda { |hsh, key| hsh[key] = new( &leet ) }
+        new(*args, &leet)
+      end
+    end
+
+    def initialize( *args, &blk )
+      @order = []
+      @order_by = nil
+      @hash = Hash.new( *args, &blk )
+    end
+
+    def order
+      reorder if @order_by
+      @order
+    end
+
+    # Keep dictionary sorted by a specific sort order.
+
+    def order_by( &block )
+      @order_by = block
+      order
+      self
+    end
+
+    # Keep dictionary sorted by key.
+    #
+    #   d = Dictionary.new.order_by_key
+    #   d["z"] = 1
+    #   d["y"] = 2
+    #   d["x"] = 3
+    #   d  #=> {"x"=>3,"y"=>2,"z"=>2}
+    #
+    # This is equivalent to:
+    #
+    #   Dictionary.new.order_by { |key,value| key }
+    #
+    # The initializer Dictionary#alpha also provides this.
+
+    def order_by_key
+      @order_by = lambda { |k,v| k }
+      order
+      self
+    end
+
+    # Keep dictionary sorted by value.
+    #
+    #   d = Dictionary.new.order_by_value
+    #   d["z"] = 1
+    #   d["y"] = 2
+    #   d["x"] = 3
+    #   d  #=> {"x"=>3,"y"=>2,"z"=>2}
+    #
+    # This is equivalent to:
+    #
+    #   Dictionary.new.order_by { |key,value| value }
+
+    def order_by_value
+      @order_by = lambda { |k,v| v }
+      order
+      self
+    end
+
+    #
+
+    def reorder
+      if @order_by
+        assoc = @order.collect{ |k| [k,@hash[k]] }.sort_by( &@order_by )
+        @order = assoc.collect{ |k,v| k }
+      end
+      @order
+    end
+
+    #def ==( hsh2 )
+    #  return false if @order != hsh2.order
+    #  super hsh2
+    #end
+
+    def ==( hsh2 )
+      if hsh2.is_a?( Dictionary )
+        @order == hsh2.order &&
+          @hash  == hsh2.instance_variable_get("@hash")
+      else
+        false
+      end
+    end
+
+    def [] k
+      @hash[ k ]
+    end
+
+    def fetch( k )
+      @hash.fetch( k )
+    end
+
+    # Store operator.
+    #
+    #   h[key] = value
+    #
+    # Or with additional index.
+    #
+    #  h[key,index] = value
+
+    def []=(k, i=nil, v=nil)
+      if v
+        insert(i,k,v)
+      else
+        store(k,i)
+      end
+    end
+
+    def insert( i,k,v )
+      @order.insert( i,k )
+      @hash.store( k,v )
+    end
+
+    def store( a,b )
+      @order.push( a ) unless @hash.has_key?( a )
+      @hash.store( a,b )
+    end
+
+    def clear
+      @order = []
+      @hash.clear
+    end
+
+    def delete( key )
+      @order.delete( key )
+      @hash.delete( key )
+    end
+
+    def each_key
+      order.each { |k| yield( k ) }
+      self
+    end
+
+    def each_value
+      order.each { |k| yield( @hash[k] ) }
+      self
+    end
+
+    def each
+      order.each { |k| yield( k,@hash[k] ) }
+      self
+    end
+    alias each_pair each
+
+    def delete_if
+      order.clone.each { |k| delete k if yield }
+      self
+    end
+
+    def values
+      ary = []
+      order.each { |k| ary.push @hash[k] }
+      ary
+    end
+
+    def keys
+      order
+    end
+
+    def invert
+      hsh2 = self.class.new
+      order.each { |k| hsh2[@hash[k]] = k }
+      hsh2
+    end
+
+    def reject( &block )
+      self.dup.delete_if(&block)
+    end
+
+    def reject!( &block )
+      hsh2 = reject(&block)
+      self == hsh2 ? nil : hsh2
+    end
+
+    def replace( hsh2 )
+      @order = hsh2.order
+      @hash = hsh2.hash
+    end
+
+    def shift
+      key = order.first
+      key ? [key,delete(key)] : super
+    end
+
+    def unshift( k,v )
+      unless @hash.include?( k )
+        @order.unshift( k )
+        @hash.store( k,v )
+        true
+      else
+        false
+      end
+    end
+
+    def <<(kv)
+      push(*kv)
+    end
+
+    def push( k,v )
+      unless @hash.include?( k )
+        @order.push( k )
+        @hash.store( k,v )
+        true
+      else
+        false
+      end
+    end
+
+    def pop
+      key = order.last
+      key ? [key,delete(key)] : nil
+    end
+
+    def to_a
+      ary = []
+      each { |k,v| ary << [k,v] }
+      ary
+    end
+
+    def to_s
+      self.to_a.to_s
+    end
+
+    def inspect
+      ary = []
+      each {|k,v| ary << k.inspect + "=>" + v.inspect}
+      '{' + ary.join(", ") + '}'
+    end
+
+    def dup
+      self.class[*to_a.flatten]
+    end
+
+    def update( hsh2 )
+      hsh2.each { |k,v| self[k] = v }
+      reorder
+      self
+    end
+    alias merge! update
+
+    def merge( hsh2 )
+      self.dup.update(hsh2)
+    end
+
+    def select
+      ary = []
+      each { |k,v| ary << [k,v] if yield k,v }
+      ary
+    end
+
+    def find
+      each{|k,v| return k, v if yield(k,v) }
+      return nil
+    end
+
+    def first
+      @hash[order.first]
+    end
+
+    def last
+      @hash[order.last]
+    end
+
+    def length
+      @order.length
+    end
+    alias size length
+
+    def empty?
+      @hash.empty?
+    end
+
+  end
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin testing
+
+  require 'test/unit'
+
+  class TC_Dictionary < Test::Unit::TestCase
+
+    def test_create
+      hsh = Dictionary['z', 1, 'a', 2, 'c', 3]
+      assert_equal( ['z','a','c'], hsh.keys )
+    end
+
+    def test_op_store
+      hsh = Dictionary.new
+      hsh['z'] = 1
+      hsh['a'] = 2
+      hsh['c'] = 3
+      assert_equal( ['z','a','c'], hsh.keys )
+    end
+
+    def test_push
+      hsh = Dictionary['a', 1, 'c', 2, 'z', 3]
+      assert( hsh.push('end', 15) )
+      assert_equal( 15, hsh['end'] )
+      assert( ! hsh.push('end', 30) )
+      assert( hsh.unshift('begin', 50) )
+      assert_equal( 50, hsh['begin'] )
+      assert( ! hsh.unshift('begin', 60) )
+      assert_equal( ["begin", "a", "c", "z", "end"], hsh.keys )
+      assert_equal( ["end", 15], hsh.pop )
+      assert_equal( ["begin", "a", "c", "z"], hsh.keys )
+      assert_equal( ["begin", 50], hsh.shift )
+    end
+
+    def test_insert
+      # front
+      h = Dictionary['a', 1, 'b', 2, 'c', 3]
+      r = Dictionary['d', 4, 'a', 1, 'b', 2, 'c', 3]
+      assert_equal( 4, h.insert(0,'d',4) )
+      assert_equal( r, h )
+      # back
+      h = Dictionary['a', 1, 'b', 2, 'c', 3]
+      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+      assert_equal( 4, h.insert(-1,'d',4) )
+      assert_equal( r, h )
+    end
+
+    def test_update
+      # with other orderred hash
+      h1 = Dictionary['a', 1, 'b', 2, 'c', 3]
+      h2 = Dictionary['d', 4]
+      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+      assert_equal( r, h1.update(h2) )
+      assert_equal( r, h1 )
+      # with other hash
+      h1 = Dictionary['a', 1, 'b', 2, 'c', 3]
+      h2 = { 'd' => 4 }
+      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+      assert_equal( r, h1.update(h2) )
+      assert_equal( r, h1 )
+    end
+
+    def test_merge
+      # with other orderred hash
+      h1 = Dictionary['a', 1, 'b', 2, 'c', 3]
+      h2 = Dictionary['d', 4]
+      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+      assert_equal( r, h1.merge(h2) )
+      # with other hash
+      h1 = Dictionary['a', 1, 'b', 2, 'c', 3]
+      h2 = { 'd' => 4 }
+      r = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+      assert_equal( r, h1.merge(h2) )
+    end
+
+    def test_order_by
+      h1 = Dictionary['a', 3, 'b', 2, 'c', 1]
+      h1.order_by{ |k,v| v }
+      assert_equal( [1,2,3], h1.values )
+      assert_equal( ['c','b','a'], h1.keys )
+    end
+
+    def test_op_store
+      h1 = Dictionary[]
+      h1[:a] = 1
+      h1[:c] = 3
+      assert_equal( [1,3], h1.values )
+      h1[:b,1] = 2
+      assert_equal( [1,2,3], h1.values )
+      assert_equal( [:a,:b,:c], h1.keys )
+    end
+
+  end
+
+=end