ramaze 0.3.0 → 0.3.5

data/lib/ramaze/global/globalstruct.rb

@@ -17,13 +17,14 @@ module Ramaze
 
     # mapping of :adapter => to the right class-name.
     ADAPTER_ALIAS = {
-      :webrick             => :WEBrick,
       :cgi                 => :Cgi,
       :fcgi                => :Fcgi,
+      :thin                => :Thin,
+      :lsws                => :Lsws,
+      :webrick             => :WEBrick,
       :mongrel             => :Mongrel,
       :evented_mongrel     => :Mongrel,
       :swiftiplied_mongrel => :Mongrel,
-      :thin                => :Thin
     }
 
     # mapping of :cache => to the right class-name.
@@ -71,8 +72,10 @@ module Ramaze
     def adapter
       if internal = self[:adapter]
         class_name = ADAPTER_ALIAS.fetch(internal.to_sym, internal)
-        require("ramaze/adapter"/internal.to_s.downcase)
-        adapter = Ramaze::Adapter.const_get(class_name)
+        unless Ramaze::Adapter.const_defined?(class_name)
+          require("ramaze/adapter"/internal.to_s.downcase)
+        end
+        Ramaze::Adapter.const_get(class_name)
       end
     end
 

data/lib/ramaze/helper/auth.rb

@@ -37,7 +37,7 @@ module Ramaze
         end
         %{
           #{open_element}
-            <form method="POST" action="#{Rs(:login)}"
+            <form method="POST" action="#{Rs(:login)}>"
               <ul style="list-style:none;">
                 <li>Username: <input type="text" name="username" /></li>
                 <li>Password: <input type="password" name="password" /></li>

data/lib/ramaze/helper/identity.rb

@@ -3,13 +3,15 @@
 
 require 'tmpdir'
 require 'openid'
+require 'openid/store/filesystem'
+require 'openid/extensions/pape'
 
 module Ramaze
 
   openid_store_file = File.join(Dir.tmpdir, 'openid-store')
 
   # Constant for storing meta-information persistent
-  OpenIDStore = OpenID::FilesystemStore.new(openid_store_file)
+  OpenIDStore = OpenID::Store::Filesystem.new(openid_store_file)
 
   # This is called Identity to avoid collisions with the original openid.rb
   # It provides a nice and simple way to provide and control access over the
@@ -38,18 +40,26 @@ module Ramaze
       session[:openid_entry] = request.referrer
 
       openid_request = openid_consumer.begin(url)
-      case openid_request.status
-      when OpenID::FAILURE
-        flash[:error] = "OpenID - Unable to find openid server for `#{url}'"
 
-        redirect_referrer
-      when OpenID::SUCCESS
-        root         = "http://#{request.http_host}/"
-        return_to    = root[0..-2] + Rs(:openid_complete)
-        redirect_url = openid_request.redirect_url(root, return_to)
-
-        redirect(redirect_url)
+      papereq = OpenID::PAPE::Request.new
+      papereq.add_policy_uri(OpenID::PAPE::AUTH_PHISHING_RESISTANT)
+      papereq.max_auth_age = 2*60*60
+      openid_request.add_extension(papereq)
+      openid_request.return_to_args['did_pape'] = 'y'
+
+      root         = "http://#{request.http_host}/"
+      return_to    = root[0..-2] + Rs(:openid_complete)
+      immediate = false
+      if openid_request.send_redirect?(root, return_to, immediate)
+        redirect_url = openid_request.redirect_url(root, return_to, immediate)
+        raw_redirect redirect_url
+      else
+        # what the hell is @form_text ?
       end
+
+    rescue OpenID::OpenIDError => ex
+      flash[:error] = "Discovery failed for #{url}: #{ex}"
+      raw_redirect Rs(:/)
     end
 
     # After having authenticated at the OpenID server browsers are redirected
@@ -60,19 +70,19 @@ module Ramaze
     # TODO:
     #   - maybe using StackHelper, but this is a really minimal overlap?
     def openid_complete
-      openid_response = openid_consumer.complete(request.params)
+      openid_response = openid_consumer.complete(request.params, request.request_uri)
 
       case openid_response.status
-      when OpenID::FAILURE
+      when OpenID::Consumer::FAILURE
         flash[:error] = 'OpenID - Verification failed.'
-      when OpenID::SUCCESS
+      when OpenID::Consumer::SUCCESS
         session[:openid_identity] = openid_response.identity_url
         flash[:success] = 'OpenID - Verification done.'
       end
 
       session.delete(:_openid_consumer_service)
 
-      redirect session[:openid_entry]
+      raw_redirect session[:openid_entry]
     end
 
     private

data/lib/ramaze/helper/link.rb

@@ -26,14 +26,19 @@ module Ramaze
     #   A('title', :href => '/foo?x=y') #> <a href="/foo?x=y">title</a>
     #   A('Home', :href => Rs(:/))      #> <a href="/foo/bar">Home</a>
 
-    def A(title, hash = {})
-      hash[:href] ||= (Rs(title) rescue title)
-      hash[:href].to_s.sub!(/\A[^\/?]+/){|m| CGI.escape(m) }
+    def A(*args)
+      hash = args.last.respond_to?(:to_hash) ? args.pop : {}
+
+      hash[:href] ||= Rs(*args)
+      title = hash.delete(:title) ||
+              (args.last.respond_to?(:to_s) ? args.last : nil) ||
+              hash[:href]
+      hash[:href].to_s.sub!(/\A[^\/?]+/) {|m| CGI.escape(m) }
 
       args = ['']
-      hash.each{|k,v| args << %(#{k}="#{v}") if k and v }
+      hash.each {|k,v| args << %(#{k}="#{v}") if k and v }
 
-      %(<a#{args.join(' ')}>#{title || hash[:href]}</a>)
+      %(<a#{args.join(' ')}>#{title}</a>)
     end
 
     # Builds links out of segments.
@@ -79,7 +84,8 @@ module Ramaze
     # Uses R with Controller.current as first element.
 
     def Rs(*atoms)
-      R(Controller.current, *atoms)
+      atoms.unshift Controller.current unless atoms.first.is_a?(Controller)
+      R(*atoms)
     end
 
     # Give it a path with character to split at and one to join the crumbs with.
@@ -94,11 +100,26 @@ module Ramaze
     #   <a href="/path">path</a>/
     #   <a href="/path/to">to</a>/
     #   <a href="/path/to/somewhere">somewhere</a>
+    #
+    # Optionally a href prefix can be specified which generate link
+    # names a above, but with the prefix prepended to the href path.
+    #
+    # Example:
+    #   breadcrumbs('/path/to/somewhere', '/', '/', '/mycontroller/action')
+    #
+    #   # results in this, newlines added for readability:
+    #
+    #   <a href="/mycontroller/action/path">path</a>/
+    #   <a href="/mycontroller/action/path/to">to</a>/
+    #   <a href="/mycontroller/action/path/to/somewhere">somewhere</a>
 
-    def breadcrumbs(path, split = '/', join = '/')
+    def breadcrumbs(path, split = '/', join = '/', href_prefix = '')
       atoms = path.split(split).reject{|a| a.empty?}
       crumbs = atoms.inject([]){|s,v| s << [s.last,v]}
-      bread = crumbs.map{|a| A(a[-1], :href=>(a*'/'))}
+      bread = crumbs.map do |a|
+        href_path = href_prefix + a*'/'
+        A(a[-1], :href=>(href_path))
+      end
       bread.join(join)
     end
   end

data/lib/ramaze/helper/maruku.rb

@@ -0,0 +1,7 @@
+module Ramaze
+  module MarukuHelper
+    def maruku(text)
+      Maruku.new(text).to_html
+    end
+  end
+end

data/lib/ramaze/helper/partial.rb

@@ -47,19 +47,34 @@ module Ramaze
       options.keys.each {|x| Request.current.params[x] = saved[x] }
     end
 
-    # Generate from a filename in template_root of the given (or current)
-    # controller a new action.
-    # Any option you don't pass is instead taken from Action.current
+    # Render the template file in template_root of the
+    # current controller.
 
-    def render_template(file, options = {})
+    def render_template(file, locals = {})
       current = Action.current
-      options[:controller] ||= current.controller
-      options[:instance]   ||= current.instance.dup
-      options[:binding]    ||= options[:instance].instance_eval{ binding }
-      options[:template] = (options[:controller].template_root/file)
+      options = { :controller => current.controller,
+                  :instance => current.instance.dup }
 
-      action = Ramaze::Action(options)
-      action.render
+      filename = options[:controller].template_root/file
+
+      if File.exist?(filename)
+        options[:template] = filename
+      elsif files = Dir["#{filename}.*"] and files.any?
+        options[:template] = files.first
+      else
+        Inform.warn "render_template: #{filename} does not exist"
+        return ''
+      end
+
+      # use method_missing to provide access to locals, if any exist
+      options[:instance].meta_def(:method_missing) { |sym, *args|
+        return locals[sym] if locals.key?(sym)
+        super
+      } if locals.any?
+
+      options[:binding]  = options[:instance].instance_eval{ binding }
+
+      Ramaze::Action(options).render
     ensure
       Thread.current[:action] = current
     end

data/lib/ramaze/route.rb

@@ -0,0 +1,56 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+# 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
+
+module Ramaze
+  class Route
+    trait :routes => Dictionary.new
+
+    class << self
+      def [](key)
+        trait[:routes][key]
+      end
+
+      def []=(key, value)
+        trait[:routes][key] = value
+      end
+    end
+  end
+
+  def self.Route(name, &block)
+    Route[name] = block
+  end
+end

data/lib/ramaze/snippets/metaid.rb

@@ -0,0 +1,17 @@
+# from http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+
+class Object
+  # The hidden singleton lurks behind everyone
+  def metaclass; class << self; self; end; end
+  def meta_eval &blk; metaclass.instance_eval &blk; end
+
+  # Adds methods to a metaclass
+  def meta_def name, &blk
+    meta_eval { define_method name, &blk }
+  end
+
+  # Defines an instance method within a class
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
+  end
+end

data/lib/ramaze/spec/helper.rb

@@ -72,8 +72,6 @@ shared 'xpath' do
   require 'rexml/document'
   require 'rexml/xpath'
 
-  include REXML
-
   class Rack::MockResponse
     def match(xpath = '*')
       REXML::XPath::match(REXML::Document.new(body), xpath)

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

@@ -26,6 +26,8 @@ module MockHTTP
     :referrer => 'HTTP_REFERER',
     :referer => 'HTTP_REFERER',
     :cookie => 'HTTP_COOKIE',
+    :if_none_match=> 'HTTP_IF_NONE_MATCH',
+    :if_modified_since=> 'HTTP_IF_MODIFIED_SINCE',
   }
 
   MOCK_REQUEST = ::Rack::MockRequest.new(Ramaze::Adapter::Fake)
@@ -40,6 +42,10 @@ module MockHTTP
     MOCK_REQUEST.send(meth, uri, DEFAULTS.merge(options))
   end
 
+  def raw_mock_request(meth, uri, options = {})
+    MOCK_REQUEST.send(meth, uri, DEFAULTS.merge(options))
+  end
+
   def process_request(path, query)
     options = {}
     FISHING.each{|key, value|

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

@@ -4,15 +4,18 @@ module Bacon
 
     def handle_specification(name)
       NAME.replace name
+			puts NAME
       yield
+			puts
     end
 
     def handle_requirement(description)
+	    print "- #{description}\n"
       error = yield
 
       unless error.empty?
         if defined?(Ramaze::Informing)
-          puts '', " #{NAME} -- #{description} ".center(70, '-'), ''
+          puts '', " #{NAME} -- #{description} [FAILED]".center(70, '-'), ''
           colors = Ramaze::Informer::COLORS
 
           until RamazeLogger.log.empty?
@@ -35,6 +38,7 @@ module Bacon
     end
 
     def handle_summary
+	    puts
       puts "%d tests, %d assertions, %d failures, %d errors" %
         Counter.values_at(:specifications, :requirements, :failed, :errors)
     end

data/lib/ramaze/store/default.rb

@@ -34,7 +34,9 @@ module Ramaze
       # pass on all methods inside a transaction
 
       def method_missing(meth, *args, &block)
-        @db.transaction do
+        read_only = (meth == :[])
+
+        @db.transaction(read_only) do
           @db.send(meth, *args, &block)
         end
       end

data/lib/ramaze/template.rb

@@ -16,7 +16,7 @@ module Ramaze
 
     ENGINES = {} unless defined?(ENGINES)
 
-    %w[ Amrita2 Erubis Haml Liquid Markaby Nagoro None Remarkably Sass XSLT ].
+    %w[ Amrita2 Builder Erubis Haml Liquid Markaby Nagoro None RedCloth Remarkably Sass XSLT ].
       each do |const|
       autoload(const, "ramaze/template/#{const.downcase}")
     end

data/lib/ramaze/template/amrita2.rb

@@ -1,7 +1,16 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-require 'amrita2/template'
+require 'amrita2'
+
+class Amrita2::Template
+
+  # Ramaze helpers are available in template contexts.
+
+  include Ramaze::Helper
+  extend Ramaze::Helper
+  helper :link, :file, :flash, :cgi
+end
 
 module Ramaze
   module Template
@@ -11,27 +20,24 @@ module Ramaze
 
     class Amrita2 < Template
 
-      ENGINES[self] = %w[ amrita amr ]
+      ENGINES[self] = %w[ amrita amr a2html ]
 
       class << self
 
         # Takes an Action
-        # The file is rendered using Amrita2::TemplateFile.
-        # The Controller is used as the object for expansion.
+        # The result or file is rendered using Amrita2::Template.
         #
-        # The parameters are set to @params in the controller before expansion.
-
-        def transform action
-          instance, file = action.instance, action.template
+        # The context data are set to @data in the controller before expansion.
 
-          raise Ramaze::Error::NoAction,
-                "No Amrita2 template found for `#{action.path}' on #{action.controller}" unless file
+        def transform(action)
+          template = wrap_compile(action)
+          data = action.instance.instance_variable_get("@data") || {}
+          action.instance.extend ::Amrita2::Runtime if data.kind_of? Binding
+          template.render_with(data)
+        end
 
-          template = ::Amrita2::TemplateFile.new(file)
-          out = ''
-          instance.instance_variable_set('@params', action.params)
-          template.expand(out, instance)
-          out
+        def compile(action, template)
+          ::Amrita2::Template.new(template)
         end
       end
     end