ramaze 0.3.5 → 0.3.9

data/lib/ramaze/spec.rb

@@ -0,0 +1 @@
+require 'ramaze/spec/helper'

data/lib/ramaze/spec/helper.rb

@@ -3,11 +3,9 @@
 
 begin
   require 'rubygems'
-rescue LoadError => ex
+rescue LoadError
 end
 
-require 'timeout'
-
 require 'ramaze'
 require 'ramaze/spec/helper/bacon'
 
@@ -112,3 +110,13 @@ shared 'xpath' do
     end
   end
 end
+
+shared 'resolve' do
+  def resolve(url)
+    Ramaze::Controller::resolve(url)
+  end
+
+  def stack(url, &block)
+    resolve(url).stack(&block)
+  end
+end

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

@@ -2,7 +2,7 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 class Browser
-  attr_reader :cookie
+  attr_reader :cookie, :http
 
   def initialize(url = '/', base = '/', &block)
     @base     = base
@@ -42,6 +42,30 @@ class Browser
     erequest(:get, url, hash)
   end
 
+  def hget(*args)
+    @page = Hpricot(get(*args))
+  end
+
+  def hpost(*args)
+    @page = Hpricot(post(*args))
+  end
+
+  def find_link(text)
+    link = @page.at("a[text()='#{text}']")
+    link.should.not.be.nil if link.respond_to?(:should)
+    link[:href]
+  end
+
+  def follow_link(text)
+    hget find_link(text)
+  end
+
+  def follow_links(*texts)
+    texts.each do |text|
+      follow_link text
+    end
+  end
+
   def request method, url, hash = {}
     @http.uri = url2uri(url)
     @http.request_headers['referer'] = @history.last.path rescue '/'

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

@@ -14,12 +14,12 @@ module Bacon
       error = yield
 
       unless error.empty?
-        if defined?(Ramaze::Informing)
+        if defined?(Ramaze::Logging)
           puts '', " #{NAME} -- #{description} [FAILED]".center(70, '-'), ''
           colors = Ramaze::Informer::COLORS
 
-          until RamazeLogger.log.empty?
-            tag, line = RamazeLogger.log.shift
+          until RamazeLogger.history.empty?
+            tag, line = RamazeLogger.history.shift
             out = "%6s | %s" % [tag.to_s, line]
             puts out.send(colors[tag])
           end
@@ -45,30 +45,30 @@ module Bacon
   end
 end
 
-if defined?(Ramaze::Informing)
+if defined?(Ramaze::Logging)
   module Ramaze
     class SpecLogger
-      include Ramaze::Informing
+      include Ramaze::Logging
       include Enumerable
 
-      attr_accessor :log
+      attr_accessor :history
 
       def initialize
-        @log = []
+        @history = []
       end
 
       def each
-        @log.each{|e| yield(e) }
+        @history.each{|e| yield(e) }
       end
 
-      def inform(tag, str)
-        @log << [tag, str]
+      def log(tag, str)
+        @history << [tag, str]
       end
     end
   end
 
   module Bacon::PrettyOutput
     RamazeLogger = Ramaze::SpecLogger.new
-    Ramaze::Inform.loggers = [RamazeLogger]
+    Ramaze::Log.loggers = [RamazeLogger]
   end
 end

data/lib/ramaze/template.rb

@@ -16,16 +16,17 @@ module Ramaze
 
     ENGINES = {} unless defined?(ENGINES)
 
-    %w[ Amrita2 Builder Erubis Haml Liquid Markaby Nagoro None RedCloth Remarkably Sass XSLT ].
-      each do |const|
+    AVAILABLE_ENGINES = %w[ Amrita2 Builder Erubis Haml Liquid Markaby Nagoro None RedCloth Remarkably Sass XSLT Tenjin Tagz ]
+
+    AVAILABLE_ENGINES.each do |const|
       autoload(const, "ramaze/template/#{const.downcase}")
     end
 
     # The superclass for all templates, contains the shared behaviour of
-    # the templates and includes Ramaze::Helper
+    # the templates and includes Ramaze::Helper::Methods
 
     class Template
-      include Ramaze::Helper
+      include Ramaze::Helper::Methods
 
       class << self
 

data/lib/ramaze/template/amrita2.rb

@@ -7,9 +7,8 @@ class Amrita2::Template
 
   # Ramaze helpers are available in template contexts.
 
-  include Ramaze::Helper
-  extend Ramaze::Helper
-  helper :link, :file, :flash, :cgi
+  include Ramaze::Helper::Methods
+  helper :link, :sendfile, :flash, :cgi
 end
 
 module Ramaze

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

@@ -56,8 +56,7 @@
 class Ezamar::Element
   attr_accessor :content
 
-  include Ramaze::Helper
-  extend Ramaze::Helper
+  include Ramaze::Helper::Methods
 
   helper :redirect, :link
 
@@ -137,7 +136,7 @@ class Ezamar::Element
 
       instance.render
     rescue => ex
-      Ramaze::Inform.debug(ex.message)
+      Ramaze::Log.debug(ex.message)
       ''
     end
 

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

@@ -1,11 +1,10 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-require 'ramaze/template/ezamar/engine'
 begin
   require 'hpricot'
 rescue LoadError => ex
-  Ramaze::Inform.error "Please install hpricot (for example via `gem install hpricot`) to get morphing"
+  Ramaze::Log.error "Please install hpricot (for example via `gem install hpricot`) to get morphing"
   puts ex
 end
 

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

@@ -9,7 +9,7 @@ module Ezamar
   # A transformer for <render /> tags.
 
   class RenderPartial
-    extend Ramaze::PartialHelper
+    extend Ramaze::Helper::Partial
 
     # Renders <render src="/path" [optional="option", ...]> in place.
     #

data/lib/ramaze/template/haml.rb

@@ -19,14 +19,17 @@ module Ramaze
 
         def transform action
           haml = wrap_compile(action)
-          haml.to_html(action.instance)
+          haml.to_html(action.instance, action.binding.locals)
         end
 
         # Instantiates Haml::Engine with the template and haml_options trait from
         # the controller.
 
         def compile(action, template)
-          ::Haml::Engine.new(template, action.controller.trait[:haml_options] || {})
+          opts = action.controller.trait[:haml_options] || {}
+          opts.merge! :filename => action.template if action.template
+
+          ::Haml::Engine.new(template, opts)
         end
       end
     end

data/lib/ramaze/template/markaby.rb

@@ -10,6 +10,8 @@ module Ramaze
     # Can be found at: http://code.whytheluckystiff.net/markaby/
 
     class Markaby < Template
+      include Ramaze::Helper::Methods
+
       ENGINES[self] = %w[ mab ]
 
       class << self

data/lib/ramaze/template/tagz.rb

@@ -0,0 +1,79 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require "tagz"
+
+module Ramaze
+  module Template
+
+    # 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 
+
+    class Tagz < Template
+      ENGINES[self] = %w[ rb tagz ] 
+
+      class << self
+
+        # Entry point for Action#render
+
+        def transform action
+          result, file = result_and_file(action)
+          if file
+            markup = "tagz{#{ file }}" 
+            action.instance.extend Methods
+            result = eval markup, action.binding, file 
+          end
+          result
+        end
+
+      end
+
+      # Methods defines a host of methods useful inside the context of a view
+      # including print style methods that output content rather that printing to
+      # STDOUT
+
+      module Methods
+        include ::Tagz
+
+      private
+        def << s
+          tagz << s; self 
+        end
+
+        def concat *a 
+          a.each{|s| tagz << s}; self
+        end
+
+        def puts *a
+          a.each{|elem| tagz << "#{ elem.to_s.chomp }#{ eol }"}
+        end
+
+        def print *a
+          a.each{|elem| tagz << elem}
+        end
+
+        def p *a
+          a.each{|elem| tagz << "#{ CGI.escapeHTML elem.inspect }#{ eol }"}
+        end
+
+        def pp *a
+          a.each{|elem| tagz << "#{ CGI.escapeHTML PP.pp(elem, '') }#{ eol }"}
+        end
+
+        def eol
+          if response.content_type =~ %r|text/plain|io
+            "\n"
+          else
+            "<br />"
+          end
+        end
+
+        def __ *a
+          concat eol 
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/template/tenjin.rb

@@ -0,0 +1,34 @@
+require "tenjin"
+require "tempfile"
+
+class Tenjin::Context
+  include Ramaze::Helper::Methods
+  helper :link, :sendfile, :flash, :cgi
+end
+
+module Ramaze
+  module Template
+
+    # Is responsible for compiling a template using the Tenjin templating engine.
+    # Can be found at: http://www.kuwata-lab.com/tenjin/
+
+    class Tenjin < Template
+
+      ENGINES[self] = %w[ rbhtml tenjin ]
+
+      class << self
+        def transform(action)
+          tenjin = wrap_compile(action)
+          context = action.instance.instance_variable_get("@context") || {}
+          tenjin.render(context)
+        end
+
+        def compile(action, template)
+          tenjin = ::Tenjin::Template.new
+          tenjin.convert(template)
+          return tenjin
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/tool/create.rb

@@ -1,9 +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 'fileutils'
-require 'yaml'
-
 module Ramaze
   module Tool
 

data/lib/ramaze/tool/localize.rb

@@ -12,149 +12,151 @@ require 'ya2yaml'
 #
 #   Ramaze::Dispatcher::Action::FILTER << Ramaze::Tool::Localize
 
-class Ramaze::Tool::Localize
+module Ramaze
+  class Tool::Localize
 
-  # Enable Localization
-  trait :enable => true
+    # Enable Localization
+    trait :enable => true
 
-  # Default language that is used if the browser don't suggests otherwise or
-  # the language requested is not available.
-  trait :default_language => 'en'
+    # Default language that is used if the browser don't suggests otherwise or
+    # the language requested is not available.
+    trait :default_language => 'en'
 
-  # languages supported
-  trait :languages => %w[ en ]
+    # languages supported
+    trait :languages => %w[ en ]
 
-  # YAML files the localizations are saved to and loaded from, %s is
-  # substituted by the values from trait[:languages]
-  trait :file => 'conf/locale_%s.yaml'.freeze
+    # YAML files the localizations are saved to and loaded from, %s is
+    # substituted by the values from trait[:languages]
+    trait :file => 'conf/locale_%s.yaml'.freeze
 
-  # The pattern that is substituted with the translation of the current locale.
-  trait :regex => /\[\[(.*?)\]\]/
+    # The pattern that is substituted with the translation of the current locale.
+    trait :regex => /\[\[(.*?)\]\]/
 
-  # Browsers may send different keys for the same language, this allows you to
-  # do some coercion between what you use as keys and what the browser sends.
-  trait :mapping => { 'en-us' => 'en', 'ja' => 'jp'}
+    # Browsers may send different keys for the same language, this allows you to
+    # do some coercion between what you use as keys and what the browser sends.
+    trait :mapping => { 'en-us' => 'en', 'ja' => 'jp'}
 
-  # When this is set to false, it will not save newly collected translatable
-  # strings to disk.  Disable this for production use, as it slows the
-  # application down.
-  trait :collect => true
+    # When this is set to false, it will not save newly collected translatable
+    # strings to disk.  Disable this for production use, as it slows the
+    # application down.
+    trait :collect => true
 
-  class << self
+    class << self
 
-    include Ramaze::Trinity
+      include Trinity
 
-    # Enables being plugged into Dispatcher::Action::FILTER
+      # Enables being plugged into Dispatcher::Action::FILTER
 
-    def call(response, options = {})
-      return response unless trait[:enable]
-      return response if response.body.nil?
-      return response if response.body.respond_to?(:read)
-      response.body = localize_body(response.body, options)
-      response
-    end
+      def call(response, options = {})
+        return response unless trait[:enable]
+        return response if response.body.nil?
+        return response if response.body.respond_to?(:read)
+        response.body = localize_body(response.body, options)
+        response
+      end
 
-    # Localizes a response body.  It reacts to a regular expression as given
-    # in trait[:regex].  Every 'entity' in it will be translated, see
-    # `localize` for more information.
+      # Localizes a response body.  It reacts to a regular expression as given
+      # in trait[:regex].  Every 'entity' in it will be translated, see
+      # `localize` for more information.
 
-    def localize_body(body, options)
-      locale =
-        if trait[:languages].include?(response["Content-Language"])
-          response["Content-Language"]
-        else
-          (session[:LOCALE] || set_session_locale).to_s
-        end
+      def localize_body(body, options)
+        locale =
+          if trait[:languages].include?(response["Content-Language"])
+            response["Content-Language"]
+          else
+            (session[:LOCALE] || set_session_locale).to_s
+          end
 
-      body.gsub!(trait[:regex]) do
-        localize($1, locale) unless $1.to_s.empty?
-      end
+        body.gsub!(trait[:regex]) do
+          localize($1, locale) unless $1.to_s.empty?
+        end
 
-      store(locale, trait[:default_language]) if trait[:collect]
+        store(locale, trait[:default_language]) if trait[:collect]
 
-      body
-    end
+        body
+      end
 
-    # Localizes a single 'entity'.  If a translation in the chosen language is
-    # not available, it falls back to the default language.
+      # Localizes a single 'entity'.  If a translation in the chosen language is
+      # not available, it falls back to the default language.
 
-    def localize(str, locale)
-      default_language = trait[:default_language]
-      dict = dictionary
-      dict[locale] ||= {}
-      dict[default_language] ||= {}
+      def localize(str, locale)
+        default_language = trait[:default_language]
+        dict = dictionary
+        dict[locale] ||= {}
+        dict[default_language] ||= {}
 
-      trans = dict[locale].fetch(str, dict[default_language][str])
-      dict[locale][str] ||= trans
-      dict[default_language][str] ||= trans
+        trans = dict[locale].fetch(str, dict[default_language][str])
+        dict[locale][str] ||= trans
+        dict[default_language][str] ||= trans
 
-      trans
-    rescue Object => ex
-      Ramaze::Inform.error(ex)
-      str
-    end
+        trans
+      rescue Object => ex
+        Log.error(ex)
+        str
+      end
 
-    # Sets session[:LOCALE] to one of the languages defined in the dictionary.
-    # It first tries to honor the browsers accepted languages and then falls
-    # back to the default language.
+      # Sets session[:LOCALE] to one of the languages defined in the dictionary.
+      # It first tries to honor the browsers accepted languages and then falls
+      # back to the default language.
 
-    def set_session_locale
-      session[:LOCALE] = trait[:default_language]
-      accepted_langs = request.http_accept_language rescue 'en'
+      def set_session_locale
+        session[:LOCALE] = trait[:default_language]
+        accepted_langs = request.http_accept_language rescue 'en'
 
-      mapping = trait[:mapping]
-      dict = dictionary
-      accepted_langs = accepted_langs.scan(/([^,;]+)(?:;q=[^,]+)?/m)[0]
+        mapping = trait[:mapping]
+        dict = dictionary
+        accepted_langs = accepted_langs.scan(/([^,;]+)(?:;q=[^,]+)?/m)[0]
 
-      accepted_langs.each do |language|
-        language = mapping[language] || language
-        if dict.key?(language)
-          session[:LOCALE] = language
-          break
+        accepted_langs.each do |language|
+          language = mapping[language] || language
+          if dict.key?(language)
+            session[:LOCALE] = language
+            break
+          end
         end
-      end
 
-      session[:LOCALE]
-    end
+        session[:LOCALE]
+      end
 
-    # Returns the dictionary used for translation.
+      # Returns the dictionary used for translation.
 
-    def dictionary
-      trait[:languages].map! {|x| x.to_s }.uniq!
-      trait[:dictionary] || load(*trait[:languages])
-    end
+      def dictionary
+        trait[:languages].map! {|x| x.to_s }.uniq!
+        trait[:dictionary] || load(*trait[:languages])
+      end
 
-    # Load given locales from disk and save it into the dictionary.
+      # Load given locales from disk and save it into the dictionary.
 
-    def load(*locales)
-      Ramaze::Inform.debug "loading locales: #{locales.inspect}"
+      def load(*locales)
+        Log.debug "loading locales: #{locales.inspect}"
 
-      dict = trait[:dictionary] || {}
+        dict = trait[:dictionary] || {}
 
-      locales.each do |locale|
-        begin
-          dict[locale] = YAML.load_file(trait[:file] % locale)
-        rescue Errno::ENOENT
-          dict[locale] = {}
+        locales.each do |locale|
+          begin
+            dict[locale] = YAML.load_file(trait[:file] % locale)
+          rescue Errno::ENOENT
+            dict[locale] = {}
+          end
         end
-      end
 
-      trait[:dictionary] = dict
-    end
+        trait[:dictionary] = dict
+      end
 
-    # Stores given locales from the dictionary to disk.
+      # Stores given locales from the dictionary to disk.
 
-    def store(*locales)
-      locales.uniq.compact.each do |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|
-          fd.write data
+      def store(*locales)
+        locales.uniq.compact.each do |locale|
+          Log.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|
+            fd.write data
+          end
         end
+      rescue Errno::ENOENT => e
+        Log.error e
       end
-    rescue Errno::ENOENT => e
-      Ramaze::Inform.error e
     end
   end
 end