ramaze 0.1.4 → 0.2.0

data/lib/ramaze/template/nagoro.rb

@@ -0,0 +1,53 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'nagoro'
+
+module Ramaze
+  module Template
+
+    # Is responsible for compiling a template using the Nagoro templating engine.
+
+    class Nagoro < Template
+
+      ENGINES[self] = %w[ xhtml nag ]
+
+      LISTENERS = [ :Element, :Morpher, :Include, :Instruction ]
+
+      TEMPLATE = ::Nagoro::Template[LISTENERS]
+
+      class << self
+
+        # Transforms an action into the XHTML code for parsing and returns
+        # the result
+        def transform action
+          nagoro = wrap_compile(action)
+          file = action.template || action.method
+          nagoro.result(action.binding, file.to_s)
+        end
+
+        def wrap_compile(action, template = nil)
+          template ||= file_or_result(action)
+          caching_compile(action, template)
+        end
+
+        def file_or_result(action)
+          result = render_method(action).to_s
+
+          if file = action.template
+            return File.new(file)
+          end
+
+          result
+        end
+
+        # Compile a template, applying all transformations from the pipeline
+        # and returning an instance of ::Nagoro::Template
+
+        def compile(action, template)
+          TEMPLATE.render(template)
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/template/none.rb

@@ -0,0 +1,14 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module Template
+
+      class None < Template
+        def self.transform action
+          render_method(action)
+        end
+      end
+
+  end
+end

data/lib/ramaze/template/xslt.rb

@@ -0,0 +1,96 @@
+#          Copyright (c) 2007  Stephan Maka  stephan@spaceboyz.net
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'xml/libxml'
+require 'xml/xslt'
+require 'thread'
+
+module Ramaze
+
+  # Use the Gestalt helper to put your controller result
+  # into proper XML form
+  #
+  # TODO:
+  # * Error handling
+  # * Maybe prevent extFunction to be called by HTTP
+  module Template
+    class XSLT < Template
+      ENGINES[self] = %w[ xsl ]
+
+      XSLT_EXT_FUNCTIONS_LOCK = Mutex.new
+
+      class << self
+
+        # Entry point for Action#render
+
+        def transform action
+
+          if options = action.instance.ancestral_trait[:xslt_options] and
+              fun_xmlns = options[:fun_xmlns]
+            # If a controller uses extFunctions, lock the whole
+            # transform action with a Mutex to prevent mixing
+            # extFunction binding and callback of two controller
+            # instances with one fun_xmlns.
+            ext_functions_synchronize do
+              register_ext_functions action.instance, fun_xmlns
+              do_transform action
+            end
+
+          else
+            do_transform action
+          end
+
+        end
+
+        private
+
+        def do_transform(action)
+          result, file = result_and_file(action)
+
+          xslt = XML::XSLT.new
+          xslt.xsl = action.template
+          xslt.xml = result
+          xslt.serve
+        end
+
+        def ext_functions_synchronize &block
+          XSLT_EXT_FUNCTIONS_LOCK.synchronize &block
+        end
+
+        def register_ext_functions instance, fun_xmlns
+
+          instance.methods.each do |method|
+            if method =~ /^xslt_.+/
+              method_name = method[5..-1]
+
+              proxy_instance = make_functor(method_name.intern) { |*a|
+                instance.send method.intern, *a
+              }
+
+              XML::XSLT.extFunction method_name.gsub('_', '-'), fun_xmlns, proxy_instance
+            end
+          end
+
+        end
+
+        # Can be replaced by Ruby Facets' Functor pattern
+        def make_functor(m, &block)
+          # Create anonymous class and instantiate;
+          # anonymous because only this one object with this
+          # particular custom method should call &block
+          o = Class.new.new
+
+          class << o
+            def create_method(name, &block)
+              self.class.send(:define_method, name, &block)
+            end
+          end
+
+          o.create_method(m, &block)
+          o
+        end
+
+      end
+    end
+  end
+end

data/lib/ramaze/tool.rb

@@ -6,5 +6,4 @@ module Ramaze::Tool
   autoload :Localize, 'ramaze/tool/localize'
   autoload :Mime, 'ramaze/tool/mime'
   autoload :Record, 'ramaze/tool/record'
-  autoload :Tidy, 'ramaze/tool/tidy'
 end

data/lib/ramaze/tool/localize.rb

@@ -7,6 +7,10 @@ require 'ya2yaml'
 # Localize helps transforming arbitrary text into localized forms using
 # a simple regular expression and substituting occurences with predefined
 # snippets stored in YAML files.
+#
+# == Usage:
+#
+#   Ramaze::Dispatcher::Action::FILTER << Ramaze::Tool::Localize
 
 class Ramaze::Tool::Localize
 
@@ -55,7 +59,7 @@ class Ramaze::Tool::Localize
     # `localize` for more information.
 
     def localize_body(body, options)
-      locale = session[:LOCALE] || set_session_locale
+      locale = (session[:LOCALE] || set_session_locale).to_s
 
       body.gsub!(trait[:regex]) do
         localize($1, locale) unless $1.to_s.empty?
@@ -118,6 +122,7 @@ class Ramaze::Tool::Localize
     # Returns the dictionary used for translation.
 
     def dictionary
+      trait[:languages].map! {|x| x.to_s }.uniq!
       trait[:dictionary] || load(*trait[:languages])
     end
 
@@ -143,7 +148,7 @@ class Ramaze::Tool::Localize
 
     def store(*locales)
       locales.uniq.compact.each do |locale|
-        Ramaze::Inform.debug "saving localized to: #{trait[:file] % locale}"
+        Ramaze::Inform.dev "saving localized to: #{trait[:file] % locale}"
         data = dictionary[locale].ya2yaml
         file = trait[:file] % locale
         File.open(file, File::CREAT|File::TRUNC|File::WRONLY) do |fd|

data/lib/ramaze/trinity/request.rb

@@ -69,6 +69,7 @@ module Ramaze
       #  end
 
       def params
+        return {} if put?
         return @ramaze_params if @ramaze_params
         @rack_params ||= rack_params
         @ramaze_params = {}

data/lib/ramaze/trinity/session.rb

@@ -60,15 +60,15 @@ module Ramaze
 
     # the key used for the cookie
 
-    SESSION_KEY = '_ramaze_session_id'
+    SESSION_KEY = '_ramaze_session_id' unless defined?(SESSION_KEY)
 
     # Holds counter for IPs
 
-    IP_COUNT = Hash.new{|h,k| h[k] = []}
+    IP_COUNT = Hash.new{|h,k| h[k] = OrderedSet.new} unless defined?(IP_COUNT)
 
     # Limit the number of sessions one IP is allowed to hold.
 
-    IP_COUNT_LIMIT = 1000
+    IP_COUNT_LIMIT = 1000 unless defined?(IP_COUNT_LIMIT)
 
     class << self
 

data/lib/ramaze/version.rb

@@ -4,8 +4,8 @@
 module Ramaze #:nodoc:
   module Version #:nodoc:
     MAJOR = 0
-    MINOR = 1
-    TINY  = 4
+    MINOR = 2
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/rake_tasks/conf.rake

@@ -7,8 +7,7 @@ BIN_FILES = %w( ramaze )
 BASEDIR = File.expand_path(File.join(File.dirname(__FILE__), '..'))
 
 NAME = "ramaze"
-REV = File.read(".svn/entries")[/committed-rev="(d+)"/, 1] rescue nil
-VERS = ENV['VERSION'] || (Ramaze::VERSION + (REV ? ".#{REV}" : ""))
+VERS = Ramaze::VERSION
 COPYRIGHT = [
   "#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com",
   "# All files in this distribution are subject to the terms of the Ruby license."

data/rake_tasks/{maintaince.rake → maintenance.rake}

@@ -1,10 +1,16 @@
 desc "add copyright to all .rb files in the distribution"
 task 'add-copyright' do
+  ignore = File.readlines('doc/LEGAL').
+    select{|line| line.strip!; File.exist?(line)}.
+    map{|file| File.expand_path(file)}
+
   puts "adding copyright to files that don't have it currently"
   puts COPYRIGHT
   puts
+
   Dir['{lib,test}/**/*{.rb}'].each do |file|
-    next if file =~ /_darcs/
+    file = File.expand_path(file)
+    next if file =~ /_darcs/ or ignore.include? file
     lines = File.readlines(file).map{|l| l.chomp}
     unless lines.first(COPYRIGHT.size) == COPYRIGHT
       puts "#{file} seems to need attention, first 4 lines:"
@@ -197,11 +203,7 @@ task 'tutorial' => ['tutorial2html'] do
   end
 end
 
-desc "Update /doc/AUTORS"
-task 'authors' do
-  changes = `darcs changes`
-  authors = []
-  mapping = {}
+def authors
   author_map = {
     'm.fellinger@gmail.com'                   => 'Michael Fellinger',
     'manveru@weez-int.com'                    => 'Michael Fellinger',
@@ -210,26 +212,32 @@ task 'authors' do
     'rff.rff@gmail.com'                       => 'Gabriele Renzi',
     'comp.lang.zenix+ramaze@gmail.com'        => 'zenix',
     'jesuswasramazing.10.pistos@geoshell.com' => 'Pistos',
+    'stephan@spaceboyz.net'                   => 'Stephan Maka',
   }
-  changes.split("\n").grep(/^\w/).each do |line|
-    splat  = line.split
-    author = splat[6..-1]
-    email  = author.pop
-    email.gsub!(/<(.*?)>/, '\1')
+
+  mapping = {}
+  `darcs changes`.split("\n").grep(/^\w/).each do |line|
+    author = line.split[6..-1]
+    email  = author.pop.gsub(/<(.*?)>/, '\1')
     name   = author.join(' ')
     name   = author_map[email] if name.empty?
-    mapping[name] = email
+    mapping[name] ||= { :email => email, :patches => 0 }
+    mapping[name][:patches] += 1
   end
-  pp mapping
 
-  max = mapping.map{|k,v| k.size}.max
+  max = mapping.map{|k,v| k.length}.max
+  mapping.inject({}) {|h,(k,v)| h[k.ljust(max)] = v; h}
+end
 
+desc "Update /doc/AUTHORS"
+task 'authors' do
   File.open('doc/AUTHORS', 'w+') do |fp|
-    fp.puts("Following persons (in alphabetical order) have contributed to Ramaze:")
+    fp.puts "Following persons (in alphabetical order) have contributed to Ramaze:"
     fp.puts
-    mapping.sort_by{|k,v| k}.each do |name, email|
-      fp.puts("#{name.ljust(max)} - #{email}")
+    authors.sort_by{|k,v| k}.each do |name, author|
+      fp.puts "   #{name}  -  #{author[:email]}"
     end
+    fp.puts
   end
 end
 

data/spec/contrib/auto_params.rb

@@ -0,0 +1,97 @@
+require 'spec/helper'
+testcase_requires 'ruby2ruby'
+
+require 'ramaze/contrib'
+Ramaze.contrib :auto_params
+
+module AnotherController
+  def another_page
+    'another page'
+  end
+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
+
+describe 'Parameterized actions' do
+  before(:all) { 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
+  before(:all) { 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
+end

data/spec/contrib/route.rb

@@ -0,0 +1,60 @@
+require 'spec/helper'
+
+require 'ramaze/contrib'
+
+class MainController < Ramaze::Controller
+  def float(flt)
+    "Float: #{flt}"
+  end
+
+  def string(str)
+    "String: #{str}"
+  end
+
+  def price(p)
+    "Price: \$#{p}"
+  end
+end
+
+describe 'Route' do
+  before :all do
+    Ramaze.contrib :route
+    ramaze
+    @route = Ramaze::Contrib::Route
+  end
+
+  it 'should be possible to define routes' do
+    @route[%r!^/(\d+\.\d{2})$!] = "/price/%.2f"
+    @route[%r!^/(\d+\.\d{2})$!].should == "/price/%.2f"
+
+    @route[%r!^/(\d+\.\d+)!] = "/float/%.3f"
+    @route[%r!^/(\d+\.\d+)!].should == "/float/%.3f"
+
+    @route[%r!^/(\w+)!] = "/string/%s"
+    @route[%r!^/(\w+)!].should == "/string/%s"
+  end
+
+  it 'should be used - /float' do
+    r = get('/123.123')
+    r.status.should == 200
+    r.body.should == 'Float: 123.123'
+  end
+
+  it 'should be used - /string' do
+    r = get('/foo')
+    r.status.should == 200
+    r.body.should == 'String: foo'
+  end
+
+  it 'should use %.3f' do
+    r = get('/123.123456')
+    r.status.should == 200
+    r.body.should == 'Float: 123.123'
+  end
+
+  it 'should resolve in the order added' do
+    r = get('/12.84')
+    r.status.should == 200
+    r.body.should == 'Price: $12.84'
+  end
+end