ramaze 0.3.9.1 → 2008.06

data/lib/ramaze/spec/helper.rb

@@ -9,22 +9,25 @@ end
 require 'ramaze'
 require 'ramaze/spec/helper/bacon'
 
-def ramaze(options = {})
-  appdir = File.dirname(caller[0].split(':').first)
-  options = {
-    :template_root => appdir/:template,
-    :public_root => appdir/:public,
-    :adapter      => false,
-    :run_loose    => true,
-    :error_page   => false,
-    :port         => 7007,
-    :host         => '127.0.0.1',
-    :force        => true,
-    :sourcereload => false,
-    :origin       => :spec,
-  }.merge(options)
-
-  Ramaze.start(options)
+# Invoke ramaze with a set of default options suitable for testing.
+# you may pass your options that will override the defaults.
+class Bacon::Context
+  # Skip start from required files
+  Ramaze.trait[:started] = true
+
+  def ramaze(options = {})
+    options = {
+      :adapter      => false,
+      :run_loose    => true,
+      :error_page   => false,
+      :port         => 7007,
+      :host         => '127.0.0.1',
+      :sourcereload => false,
+      :origin       => :spec,
+    }.merge(options)
+
+    Ramaze.start!(options)
+  end
 end
 
 SPEC_REQUIRE_DEPENDENCY = {
@@ -45,11 +48,6 @@ rescue LoadError => ex
   exit
 end
 
-def testcase_requires(*following)
-  warn "'testcase_requires' is being deprecated, please use 'spec_require' instead"
-  spec_require(*following)
-end
-
 shared "http" do
   require 'ramaze/spec/helper/mock_http'
   extend MockHTTP
@@ -61,9 +59,14 @@ shared 'browser' do
 end
 
 shared 'requester' do
+  require 'ramaze/spec/helper/mock_http'
   require 'ramaze/spec/helper/requester'
+  extend Requester
+  extend MockHTTP
 end
 
+# make it easier to use XPATH on the MockResponse#body - in cases you can't use
+# Hpricot or if you want to keep dependencies down
 shared 'xpath' do
   behaves_like 'http'
 
@@ -71,36 +74,44 @@ shared 'xpath' do
   require 'rexml/xpath'
 
   class Rack::MockResponse
+    # Delegate to REXML::XPath::match
     def match(xpath = '*')
       REXML::XPath::match(REXML::Document.new(body), xpath)
     end
     alias / match
     alias search match
 
+    # Delegate to REXML::XPath::first
     def first(xpath = '*')
       REXML::XPath::first(REXML::Document.new(body), xpath)
     end
     alias at first
 
+    # Delegate to REXML::XPath::each
     def each(xpath = '*', &block)
       REXML::XPath::each(REXML::Document.new(body), xpath, &block)
     end
   end
 
-  def xp_match(obj, xpath = '*')
-    XPath::match(rexml_doc(body), xpath, &block)
+  # Delegate to REXML::XPath::match
+  def xp_match(obj, xpath = '*', &block)
+    REXML::XPath::match(rexml_doc(obj), xpath, &block)
   end
   alias xp_search xp_match
 
-  def xp_first(obj, xpath = '*')
-    XPath::first(rexml_doc(body), xpath, &block)
+  # Delegate to REXML::XPath::first
+  def xp_first(obj, xpath = '*', &block)
+    REXML::XPath::first(rexml_doc(obj), xpath, &block)
   end
   alias xp_at xp_first
 
+  # Delegate to REXML::XPath::each
   def xp_each(obj, xpath = '*', &block)
-    XPath::each(rexml_doc(body), xpath, &block)
+    REXML::XPath::each(rexml_doc(obj), xpath, &block)
   end
 
+  # Delegate to REXML::Document.new - return the obj if it's already an
+  # instance.
   def rexml_doc(obj)
     case obj
     when REXML::Document, REXML::Element
@@ -112,10 +123,12 @@ shared 'xpath' do
 end
 
 shared 'resolve' do
+  # shortcut for Ramaze::Controller::resolve
   def resolve(url)
     Ramaze::Controller::resolve(url)
   end
 
+  # Shortcut to stack on the instance of Action return from resolve
   def stack(url, &block)
     resolve(url).stack(&block)
   end

data/lib/ramaze/spec/helper/bacon.rb

@@ -1,7 +1,7 @@
-libdir = File.expand_path(File.join(File.dirname(__FILE__), '../../../'))
-$LOAD_PATH.unshift libdir
-require 'vendor/bacon'
-require 'ramaze/spec/helper/pretty_output'
+require 'bacon'
+
+dir = File.dirname(__FILE__)
+require File.join(File.dirname(__FILE__), 'pretty_output')
+
 Bacon.extend Bacon::PrettyOutput
-# Bacon.extend Bacon::TestUnitOutput
 Bacon.summary_on_exit

data/lib/ramaze/spec/helper/mock_http.rb

@@ -2,15 +2,9 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 require 'ramaze'
+require 'ramaze/adapter/fake'
 require 'rack/mock'
 
-module Ramaze
-  module Adapter
-    class Fake < Base
-    end
-  end
-end
-
 module MockHTTP
   DEFAULTS = {
     'REMOTE_ADDR' => '127.0.0.1'

data/lib/ramaze/spec/helper/pretty_output.rb

@@ -2,6 +2,7 @@ module Bacon
   module PrettyOutput
     NAME = ''
 
+    # store name and run
     def handle_specification(name)
       NAME.replace name
 			puts NAME
@@ -9,14 +10,15 @@ module Bacon
 			puts
     end
 
+    # Core, yields the requirement and outputs problems
     def handle_requirement(description)
 	    print "- #{description}\n"
       error = yield
 
       unless error.empty?
-        if defined?(Ramaze::Logging)
+        if defined?(Ramaze::Logging::Logging)
           puts '', " #{NAME} -- #{description} [FAILED]".center(70, '-'), ''
-          colors = Ramaze::Informer::COLORS
+          colors = Ramaze::Logging::Logger::Informer::COLORS
 
           until RamazeLogger.history.empty?
             tag, line = RamazeLogger.history.shift
@@ -29,6 +31,7 @@ module Bacon
       end
     end
 
+    # Show nicer output on error
     def general_error
       puts "", ErrorLog
       ErrorLog.scan(/^\s*(.*?):(\d+): #{NAME} - (.*?)$/) do
@@ -37,6 +40,7 @@ module Bacon
       ErrorLog.replace ''
     end
 
+    # output summary
     def handle_summary
 	    puts
       puts "%d tests, %d assertions, %d failures, %d errors" %
@@ -47,20 +51,24 @@ end
 
 if defined?(Ramaze::Logging)
   module Ramaze
+    # Special Logger, stores everything in its history
     class SpecLogger
       include Ramaze::Logging
       include Enumerable
 
       attr_accessor :history
 
+      # Create new history
       def initialize
         @history = []
       end
 
+      # Yield the history
       def each
         @history.each{|e| yield(e) }
       end
 
+      # general log
       def log(tag, str)
         @history << [tag, str]
       end

data/lib/ramaze/spec/helper/requester.rb

@@ -37,6 +37,20 @@ module Requester
     ex.message
   end
 
+  def hget(url = '/', hash = {})
+    @response = get(url, hash)
+    @body = @response.body
+    @status = @response.status
+    Hpricot(@body)
+  end
+
+  def hpost(url = '/', hash = {})
+    @response = post(url, hash)
+    @body = @response.body
+    @status = @response.status
+    Hpricot(@body)
+  end
+
   def url2uri url
     uri = URI.parse(url)
     #p uri.methods.sort.grep(/=/)

data/lib/ramaze/template.rb

@@ -60,16 +60,19 @@ module Ramaze
           action.instance.__send__(method, *action.params)
         end
 
-        # This is a wrapper to use Global.compile without even thinking about it.
-        # Don't use it if your engine is not based on a compile/eval principle.
+        # This is a wrapper to use Global.compile without even thinking about
+        # it. Don't use it if your engine is not based on a compile/eval
+        # principle.
 
         def wrap_compile(action, template = nil)
           template ||= reaction_or_file(action).to_s
           caching_compile(action, template)
         end
 
+        # If Global.compile is enabled try to find the action in the cache,
+        # otherwise give a new compiled object back.
         def caching_compile(action, template)
-          if Global.compile
+          if Global.compile && action.template
             Cache.compiled[action.relaxed_hash] ||= compile(action, template)
           else
             compile(action, template)

data/lib/ramaze/template/amrita2.rb

@@ -35,6 +35,7 @@ module Ramaze
           template.render_with(data)
         end
 
+        # Compile a template, return instance of Amrita2::Template
         def compile(action, template)
           ::Amrita2::Template.new(template)
         end

data/lib/ramaze/template/erubis.rb

@@ -13,6 +13,11 @@ module Ramaze
 
       ENGINES[self] = %w[ rhtml ]
 
+      # Allow for swapping in a differnt Erubis engine (it supplies several) and
+      # passing options to the engine.
+      trait[:engine] ||= ::Erubis::Eruby
+      trait[:options] ||= {}
+
       class << self
 
         # Entry-point for Action#render
@@ -24,8 +29,9 @@ module Ramaze
 
         # Creates an instance of ::Erubis::Eruby, sets the filename
         # from the template and returns the instance.
+
         def compile(action, template)
-          eruby = ::Erubis::Eruby.new(template)
+          eruby = ancestral_trait[:engine].new(template, ancestral_trait[:options])
           eruby.init_evaluator(:filename => (action.template || __FILE__))
           eruby
         end

data/lib/ramaze/template/ezamar/render_partial.rb

@@ -2,7 +2,7 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 require 'ramaze/template/ezamar/engine'
-require 'ramaze/helper/partial'
+
 
 module Ezamar
 

data/lib/ramaze/template/nagoro.rb

@@ -24,6 +24,7 @@ module Ramaze
           nagoro.result(:file => file, :binding => action.binding)
         end
 
+        # Use file_or_result instead of reaction_or_file
         def wrap_compile(action, template = nil)
           template ||= file_or_result(action)
           caching_compile(action, template)

data/lib/ramaze/template/redcloth.rb

@@ -10,6 +10,7 @@ module Ramaze
       ENGINES[self] = %w[ redcloth ]
 
       class << self
+        # Take the action and directly transform it into html by RedCloth
         def transform(action)
           restrictions = action.controller.trait[:redcloth_options] || []
           rules = action.controller.trait[:redcloth_options] || []

data/lib/ramaze/template/tagz.rb

@@ -8,11 +8,11 @@ module Ramaze
 
     # Is responsible for compiling a template using the Tagz templating engine.
     # Can be found at: http://rubyforge.org/projects/codeforpeople/
-    #   gem install tagz 
-    # be sure you get version 1.0 or higher 
+    #   gem install tagz
+    # be sure you get version 1.0 or higher
 
     class Tagz < Template
-      ENGINES[self] = %w[ rb tagz ] 
+      ENGINES[self] = %w[ rb tagz ]
 
       class << self
 
@@ -21,9 +21,9 @@ module Ramaze
         def transform action
           result, file = result_and_file(action)
           if file
-            markup = "tagz{#{ file }}" 
+            markup = "tagz{#{ file }}"
             action.instance.extend Methods
-            result = eval markup, action.binding, file 
+            result = eval markup, action.binding, file
           end
           result
         end
@@ -39,10 +39,10 @@ module Ramaze
 
       private
         def << s
-          tagz << s; self 
+          tagz << s; self
         end
 
-        def concat *a 
+        def concat *a
           a.each{|s| tagz << s}; self
         end
 
@@ -71,7 +71,7 @@ module Ramaze
         end
 
         def __ *a
-          concat eol 
+          concat eol
         end
       end
     end

data/lib/ramaze/template/tenjin.rb

@@ -1,6 +1,9 @@
 require "tenjin"
 require "tempfile"
 
+# Tenjin does not work with a Binding, so helpers included by the controller
+# will not be automatically available in templates. Instead we add support
+# for popular helpers to its internal Context class to make them available.
 class Tenjin::Context
   include Ramaze::Helper::Methods
   helper :link, :sendfile, :flash, :cgi
@@ -11,18 +14,55 @@ module Ramaze
 
     # Is responsible for compiling a template using the Tenjin templating engine.
     # Can be found at: http://www.kuwata-lab.com/tenjin/
+    #
+    # Instance variables in your action method are automatically available in
+    # the template:
+    #
+    #  class MainController < Ramaze::Controller
+    #    engine :Tenjin
+    #    def index
+    #      @names = ['Alice', 'Bob', 'Charlie']
+    #      @greeting = 'Hello'
+    #      %q{
+    #      <html><body>
+    #        <h1><?rb for name in @names ?><p>#{@greeting} #{name}</p><?rb end ?></h1>
+    #      </body></html>
+    #      }
+    #    end
+    #  end
+    #
+    # Note that only instance vars are available and methods (including helper methods)
+    # are not available in the template. A few common helpers are made generally available
+    # though by virtue of the modifications to Tenjin::Context at the top of this file.
 
     class Tenjin < Template
 
       ENGINES[self] = %w[ rbhtml tenjin ]
 
       class << self
+        # Transforms an action into the XHTML code for parsing and returns
+        # the result.
         def transform(action)
           tenjin = wrap_compile(action)
-          context = action.instance.instance_variable_get("@context") || {}
-          tenjin.render(context)
+          # Tenjin can't deal with a Binding so we construct a hash for it.
+          tenjin.render(context(action))
         end
 
+        # Return a hash of all instance variables from the action.
+        # For each instance var @foo, we put :foo => @foo in the hash.
+        def context action
+          hash = {}
+          action_binding = action.binding
+          var_names = action.instance.instance_variables
+          var_names.each do |var_name|
+            # Strip the @ from the front of the var name to use as hash key,
+            # then simply use the value of the instance var as the hash value.
+            hash[var_name[1..-1]] = eval(var_name, action_binding)
+          end
+          hash
+        end
+
+        # Compile a template, returning an instance of ::Tenjin::Template.
         def compile(action, template)
           tenjin = ::Tenjin::Template.new
           tenjin.convert(template)

data/lib/ramaze/template/xslt.rb

@@ -44,6 +44,7 @@ module Ramaze
 
         private
 
+        # further abstraction for the transform
         def do_transform(action)
           result, file = result_and_file(action)
 
@@ -53,10 +54,12 @@ module Ramaze
           xslt.serve
         end
 
+        # Synchronize the block to run with the mutex
         def ext_functions_synchronize &block
           XSLT_EXT_FUNCTIONS_LOCK.synchronize &block
         end
 
+        # Expose functors
         def register_ext_functions instance, fun_xmlns
 
           instance.methods.each do |method|
@@ -81,6 +84,7 @@ module Ramaze
           o = Class.new.new
 
           class << o
+            # Delayed creation of method
             def create_method(name, &block)
               self.class.send(:define_method, name, &block)
             end