ramaze 2008.11 → 2009.01

data/lib/ramaze/contrib/auto_params.rb

@@ -1,135 +0,0 @@
-# auto_params.rb
-#
-# AutoParams implements action parameterization ala merb 0.4 and Nitro
-# using ruby2ruby and ParseTree
-#
-# Usage:
-#
-#   Ramaze.contrib :auto_params
-#
-# Then, for example,
-#
-#   def search(query) end
-#
-# can be accessed via
-#
-#   - /search?query=findthis, which calls search('findthis')
-#   - /search/findthis                    search('findthis')
-#   - /search/findthis?query=andthis      search(['findthis', 'andthis'])
-#
-# For more examples, take a look at spec/contrib/auto_params.rb
-#
-# Note: A simpler alternative for similar functionality would be:
-#
-#   def search(query = request['query']) end
-#
-
-require __DIR__/:auto_params/:get_args
-
-module Ramaze
-
-  module Contrib
-    class AutoParams
-      def self.startup
-        Ramaze::Cache.add :args
-      end
-    end
-  end
-
-  class Action
-
-    # with parameterization, params may include
-    #   arrays: /num?n=1&n=2 becomes [['1','2']] for def num(n) end
-    #   nil: /calc?w=10&d=2 becomes ['10', nil, '2'] for def calc(w, h, d) end
-
-    def params=(*par)
-      par = *par
-      self[:params] = par.map{ |pa|
-        case pa
-        when Array
-          pa.map{|p| Rack::Utils.unescape(p)}
-        when nil
-          nil
-        else
-          Rack::Utils.unescape(pa)
-        end
-      } unless par.nil?
-      self[:params] ||= []
-    end
-
-  end
-
-  class Controller
-
-    # ignore cache when request.params is interesting
-
-    def self.cached(path)
-      if found = Cache.resolved[path]
-        if found.respond_to?(:relaxed_hash)
-
-          # don't use cache if we need to add request.params entries to the Action
-          if args = Cache.args[found.method]
-            param_keys = request.params.keys
-            return nil if args.find{|k,v| param_keys.include?(k.to_s) }
-          end
-
-          return found.dup
-        else
-          Log.warn("Found faulty `#{path}' in Cache.resolved, deleting it for sanity.")
-          Cache.resolved.delete path
-        end
-      end
-
-      nil
-    end
-
-    # use Method#get_args to insert values from request.params into Action#params
-
-    def self.resolve_method(name, *params)
-      if method = [ name, name.gsub('__','/') ].find{|n|
-          cached_action_methods.include?(n) }
-        meth = instance_method(method)
-        arity = meth.arity
-
-        if meth.respond_to? :get_args
-          unless args = Cache.args[name]
-            if args = meth.get_args
-              args = args.select{|e| e.to_s !~ /^\*/}
-            else
-              args = []
-            end
-            Cache.args[name] = args
-          end
-
-          param_keys = request.params.keys
-
-          # if there are missing args, or keys in request.params that match expected args
-          if args.size > params.size or args.find{|k,v| param_keys.include?(k.to_s) }
-            args.each_with_index do |(name, val), i|
-              r_params = request.params[name.to_s]
-              if params[i] and r_params and r_params.size > 0
-                params[i] = [params[i], r_params].flatten
-              else
-                params[i] ||= r_params
-              end
-            end
-
-            # strip trailing nils so default argument values are used
-            params.reverse.each{|e| if e.nil? then params.pop else break end }
-          end
-
-          argity = args.select{|e| e.size==1}.size..args.size
-        else
-          argity = arity..arity
-        end
-
-        if arity < 0 or argity.include? params.size
-          return method, params
-        end
-      end
-      return nil, []
-    end
-
-  end
-
-end

data/lib/ramaze/contrib/auto_params/get_args.rb

@@ -1,58 +0,0 @@
-# from merb/core_ext/get_args.rb
-begin
-  require 'parse_tree'
-  require 'ruby2ruby'
-
-  class ParseTreeArray < Array
-    def self.translate(*args)
-      self.new(ParseTree.translate(*args))
-    end
-
-    def deep_array_node(type = nil)
-      each do |node|
-        return ParseTreeArray.new(node) if node.is_a?(Array) && (!type || node[0] == type)
-        next unless node.is_a?(Array)
-        return ParseTreeArray.new(node).deep_array_node(type)
-      end
-      nil
-    end
-
-    def arg_nodes
-      self[1..-1].inject([]) do |sum,item|
-        sum << [item] unless item.is_a?(Array)
-        sum
-      end
-    end
-
-    def get_args
-      arg_node = deep_array_node(:args)
-      return nil unless arg_node
-      args = arg_node.arg_nodes
-      default_node = arg_node.deep_array_node(:block)
-      return args unless default_node
-      lasgns = default_node[1..-1]
-      lasgns.each do |asgn|
-        args.assoc(asgn[1]) << eval(RubyToRuby.new.process(asgn[2]))
-      end
-      args
-    end
-
-  end
-
-  module GetArgs
-    def get_args
-      klass, meth = self.to_s.split(/ /).to_a[1][0..-2].split("#")
-      klass = $` if klass =~ /\(/
-      ParseTreeArray.translate(Object.const_get(klass), meth).get_args
-    end
-  end
-
-  class UnboundMethod
-    include GetArgs
-  end
-
-  class Method
-    include GetArgs
-  end
-rescue LoadError
-end

data/spec/contrib/auto_params.rb

@@ -1,121 +0,0 @@
-require 'spec/helper'
-spec_require 'parse_tree', 'ruby2ruby'
-
-Ramaze.contrib :auto_params
-
-module AnotherController
-  Ramaze::Helper::LOOKUP << self
-
-  def another_page
-    'another page'
-  end
-
-  define_method('css/style.css') { 'style.css' }
-end
-
-class MainController < Ramaze::Controller
-  include AnotherController
-  engine :None
-
-  def search query
-    query.inspect
-  end
-
-  def create name, age = '?', occupation = nil
-    [name, age, occupation].compact.join(', ')
-  end
-
-  def show *args
-    args.join(', ')
-  end
-
-  def add item, price = 1.0, *args
-    [item, price, *args].join(', ')
-  end
-
-  def find width, height, depth
-    [width, height, depth].join(', ')
-  end
-
-  define_method('page') do
-    'page'
-  end
-end
-
-class GetArgsTest
-  def one(a, b, c) end
-  def two(a, b = 1, c = nil) end
-  def three(a, *args) end
-end
-
-describe 'Method#get_args' do
-  it 'should return a list of arguments' do
-    gat = GetArgsTest.new
-    gat.method(:one).get_args.should == [[:a], [:b], [:c]]
-    gat.method(:two).get_args.should == [[:a], [:b, 1], [:c, nil]]
-    gat.method(:three).get_args.should == [[:a], [:"*args"]]
-  end
-end
-
-describe 'Parameterized actions' do
-  behaves_like 'http'
-  ramaze
-
-  it 'should pass in values from request.params' do
-    get('/create/Aman/20').body.should == 'Aman, 20'
-    get('/create', :name => 'Aman', :age => 20).body.should == 'Aman, 20'
-
-    get('/create/Aman/20/Unemployed').body.should == 'Aman, 20, Unemployed'
-    get('/create', :name => 'Aman', :age => 20, :occupation => 'Unemployed').body.should == 'Aman, 20, Unemployed'
-
-    get('/create/Aman').body.should == 'Aman, ?'
-    get('/create', :name => 'Aman').body.should == 'Aman, ?'
-  end
-
-  it 'should insert nil for arguments not found' do
-    get('/find', :width => 10, :depth => 20).body.should == '10, , 20'
-  end
-
-  it 'should work with variable arguments' do
-    get('/show/1/2/3').body.should == '1, 2, 3'
-
-    get('/add/Shoe').body.should == 'Shoe, 1.0'
-    get('/add', :item => 'Shoe').body.should == 'Shoe, 1.0'
-
-    get('/add/Shoe/10.50/1/2/3').body.should == 'Shoe, 10.50, 1, 2, 3'
-    get('/add/Shoe/11.00').body.should == 'Shoe, 11.00'
-  end
-
-  it 'should not break existing methods' do
-    get('/search/Aman').body.should == '"Aman"'
-    get('/search', 'query=Aman').body.should == '"Aman"'
-    get('/search/tmm1', 'query=Aman').body.should == ['tmm1','Aman'].inspect
-  end
-
-  it 'should consolidate all values for the same key into an array' do
-    get('/add', 'item=Shoe&item=Shirt').body.should == 'Shoe, Shirt, 1.0'
-    get('/add/Pants', 'item=Shoe&item=Shirt').body.should == 'Pants, Shoe, Shirt, 1.0'
-    get('/add/Shoe', :item => 'Shirt').body.should == 'Shoe, Shirt, 1.0'
-  end
-end if method(:puts).respond_to? :get_args
-
-describe 'Normal behavior' do
-  behaves_like 'http'
-  ramaze
-
-  it 'should work with no arguments' do
-    get('/page').body.should == 'page'
-  end
-
-  it 'should raise no action' do
-    get('/none').body.should =~ /No Action found/
-  end
-
-  it 'should work with included actions' do
-    get('/another_page').body.should == 'another page'
-  end
-
-  it 'should work with /' do
-    get('/css/style.css').body.should == 'style.css'
-  end
-end

data/spec/snippets/divide.rb

@@ -1,19 +0,0 @@
-require 'lib/ramaze/spec/helper/snippets'
-
-describe 'String#/ and Symbol#/' do
-  it 'should join two strings' do
-    ('a' / 'b').should == 'a/b'
-  end
-
-  it 'should join a string and a symbol' do
-    ('a' / :b).should == 'a/b'
-  end
-
-  it 'should join two symbols' do
-    (:a / :b).should == 'a/b'
-  end
-
-  it 'should be usable in concatenation' do
-    ('a' / :b / :c).should == 'a/b/c'
-  end
-end