manveru-ramaze 2008.09 → 2008.10

data/examples/app/rapaste/model/paste.rb

@@ -27,6 +27,9 @@ class Paste < Sequel::Model(:paste)
 
   def uv(text, style = STYLE, lines = true)
     Uv.parse(text, "xhtml", syntax, lines, style)
+  rescue ArgumentError => ex
+    Ramaze::Log::error(ex)
+    "<pre>#{text}</pre>"
   end
 
   def syntax_name

data/examples/app/rapaste/start.rb

@@ -22,4 +22,4 @@ DB = Sequel.connect("sqlite://#{DB_FILE}")
 require 'model/paste'
 require 'controller/paste'
 
-Ramaze.start
+Ramaze.start :adapter => :mongrel, :port => 9952

data/examples/app/rapaste/view/view.xhtml

@@ -1,6 +1,9 @@
 #{@pager}
 <script type="text/javascript" src="/js/jquery.js"></script>
 <script type="text/javascript">
+  $(function() {
+    $('#paste_body').dblclick(function(){ $('.line-numbers').toggle() });
+  });
   function change_style(name){
     $('link')[1].href = '/css/' + name + '.css';
     $('pre')[0].className = name;

data/examples/helpers/httpdigest.rb

@@ -4,12 +4,61 @@ require 'ramaze'
 REALM = 'ramaze authentication required'
 
 class MainController < Ramaze::Controller
+
+  helper :httpdigest
+
   def index
     %|
+    <p><a href="#{Rs(:eyes_only)}">eyes only</a></p>
     <p><a href="#{R(SecretController,'/')}">secret area</a></p>
-    <p><a href="#{R(GuestController,'/')}">guest area</a> password must be the same as username</p>
+    <p><a href="#{R(GuestController,'/')}">guest area</a> username is <em>guest</em> password is <em>access</em></p>
      | 
   end
+
+  def eyes_only
+    httpdigest('eyes only',REALM) do |username|
+      password = username.reverse
+      MD5.hexdigest([username,REALM,password].join(':'))
+    end
+    "Shhhh don't tell anyone"
+  end
+
+end
+
+class LoginController < Ramaze::Controller
+  map '/login'
+
+  helper :httpdigest
+
+  def index
+     @username ||= session[:username]
+     @username ||= httpdigest('login area',REALM)
+    "Hi there #@username!"
+  end
+
+  def login
+    %|<form action="#{Rs(:post)}" method="post"><input type="text" name="username"/><input type="password" name="password"/><input type="submit"/></form>|
+  end
+
+  def post
+    username = request.params["username"]
+    password = request.params["password"]
+    if password == "entry"
+      session[:username] = username
+      destination = session[ :redirect_after_login ]
+      session.delete( :redirect_after_login )
+      redirect destination
+    end
+    redirect Rs(:login)
+  end
+
+  protected
+
+  def httpdigest_failure
+    session[ :redirect_after_login ] = Rs(Ramaze::Action.current.method)
+    redirect Rs(:login)
+  end
+
 end
 
 class SecretController < Ramaze::Controller
@@ -17,17 +66,22 @@ class SecretController < Ramaze::Controller
   helper :aspect
   helper :httpdigest
 
+  USERS = { 'admin' => 'secret', 'root' => 'password' }
+
   before_all do
-    @username = httpdigest('secret area',REALM) do |username|
-      { 'admin' => MD5.hexdigest("admin:#{REALM}:secret"),
-        'root' => MD5.hexdigest("root:#{REALM}:access"),
-      }[ username ]
-    end
+    @username = httpdigest('secret area',REALM)
   end
 
   def index
     "Hello <em>#@username</em>, welcome to SECRET world"
   end
+
+  protected
+
+  def httpdigest_lookup_plaintext_password username
+    USERS[ username ]
+  end
+
 end
 
 class GuestController < Ramaze::Controller
@@ -36,15 +90,19 @@ class GuestController < Ramaze::Controller
   helper :httpdigest
 
   before_all do
-    @username = httpdigest('guest area',REALM) do |username|
-      username_used = username
-      MD5.hexdigest([username,REALM,username].join(':'))
-    end
+    @username = httpdigest('guest area',REALM)
   end
 
   def index
     "Hello <em>#@username</em>, welcome to GUEST world."
   end
+
+  protected
+
+  def httpdigest_lookup_password username
+    return "b71f15b2f6dd4834224fbe02169ed94c" if username == "guest"
+  end
+
 end
 
 Ramaze.start

data/lib/proto/controller/init.rb

@@ -7,4 +7,5 @@ class Controller < Ramaze::Controller
   engine :Ezamar
 end
 
-acquire __DIR__/"*.rb"
+# Here go your requires for subclasses of Controller:
+require 'controller/main'

data/lib/proto/model/init.rb

@@ -1,4 +1,4 @@
-# Here goes your database connection and options
+# Here goes your database connection and options:
 
-# Require all models in '/model/*.rb'
-acquire __DIR__/"*.rb"
+# Here go your requires for models:
+# require 'model/user'

data/lib/proto/start.rb

@@ -1,6 +1,10 @@
 require 'rubygems'
 require 'ramaze'
 
+# Add directory start.rb is in to the load path, so you can run the app from
+# any other working path
+$LOAD_PATH.unshift(__DIR__)
+
 # Initialize controllers and models
 require 'controller/init'
 require 'model/init'

data/lib/ramaze/adapter/base.rb

@@ -11,8 +11,8 @@ module Ramaze
       # Rack::Deflater,
       Ramaze::Reloader,
       Ramaze::Current,
-      Ramaze::Dispatcher,
-    ]
+      Ramaze::Dispatcher
+    ] unless defined? MIDDLEWARE
 
     def self.middleware(mws = MIDDLEWARE)
       if @middleware and trait[:previous] == mws

data/lib/ramaze/contrib.rb

@@ -49,7 +49,7 @@ module Ramaze
           const.startup if const.respond_to?(:startup)
           Log.dev "Loaded contrib: #{const}"
         rescue NameError
-          files = Dir["{contrib,#{BASEDIR/:ramaze/:contrib}}/#{name}.{so,bundle,rb}"]
+          files = Dir["{contrib,#{BASEDIR}/ramaze/contrib}/#{name}.{so,bundle,rb}"]
           raise LoadError, "#{mod_name} not found" unless files.any?
           require(files.first) ? retry : raise
         end

data/lib/ramaze/controller/resolve.rb

@@ -136,10 +136,15 @@ module Ramaze
 
       def resolve_template(path)
         path = path.to_s
-        path_converted = path.split('__').inject{|s,v| s/v}
+        path_converted = path.split('__').inject{|s,v| File.join(s, v) }
         possible_paths = [path, path_converted].compact
 
-        paths = template_paths.map{|pa| possible_paths.map{|a| pa/a } }.flatten.uniq
+        paths = template_paths.map{|pa|
+          possible_paths.map{|a|
+            File.join(pa, a)
+          }
+        }.flatten.uniq
+
         glob = "{#{paths.join(',')}}.{#{extension_order.join(',')}}"
 
         Dir[glob].first
@@ -153,7 +158,7 @@ module Ramaze
         if paths = view_root
           paths
         else
-          view_root(Global.view_root / Global.mapping.invert[self])
+          view_root(File.join(Global.view_root, Global.mapping.invert[self]))
         end
       end
 

data/lib/ramaze/controller.rb

@@ -71,9 +71,12 @@ module Ramaze
 
       def mapping
         global_mapping = Global.mapping.invert[self]
+
         return global_mapping if global_mapping
+
         if ancestral_trait[:automap] && self.to_s !~ /#<Class:/
           name = self.to_s.gsub('Controller', '').gsub('::', '/').clone
+          return if name.empty?
           name == 'Main' ? '/' : "/#{name.snake_case}"
         end
       end

data/lib/ramaze/current/request.rb

@@ -59,10 +59,8 @@ module Ramaze
     end
 
     def [](key, *rest)
-      value = params[key.to_s]
-      return value if rest.empty?
-      keys = rest.flatten.map{|k| k.to_s}
-      Array[value, *params.values_at(*keys)]
+      return params[key.to_s] if rest.empty?
+      [key, *rest].map{|k| params[k.to_s] }
     end
 
     def to_ivs(*args)

data/lib/ramaze/dispatcher/action.rb

@@ -11,9 +11,9 @@ module Ramaze
 
       # The response is passed to each filter by sending .call(response) to it.
 
-      FILTER = OrderedSet.new(
+      FILTER = OrderedSet[
         # Ramaze::Tool::Localize,
-      ) unless defined?(FILTER)
+      ] unless defined?(FILTER)
 
       class << self
         include Trinity

data/lib/ramaze/dispatcher/file.rb

@@ -64,7 +64,8 @@ module Ramaze
           joined = ::File.join(Global.public_root, path)
 
           if ::File.directory?(joined)
-            Dir[joined/"{#{INDICES.join(',')}}"].first || joined
+            glob = ::File.join(joined, "{#{INDICES.join(',')}}")
+            Dir[glob].first || joined
           else
             joined
           end

data/lib/ramaze/dispatcher.rb

@@ -20,7 +20,7 @@ module Ramaze
     end
 
     # requests are passed to every
-    FILTER = OrderedSet[ Dispatcher::File, Dispatcher::Action, ]
+    FILTER = OrderedSet[ Dispatcher::File, Dispatcher::Action ]
 
     # Response codes to cache the output of for repeated requests.
     trait :shielded => [ STATUS_CODE["Not Found"] ]

data/lib/ramaze/helper/formatting.rb

@@ -148,7 +148,7 @@ module Ramaze
       diff = max - min
 
       tags.uniq.each do |tag|
-        count = tags.count(tag)
+        count = tags.respond_to?(:count) ? tags.count(tag) : tags.select{|t| t==tag }.size
         result[tag] = ((count / total) * diff) + min
       end
 

data/lib/ramaze/helper/httpdigest.rb

@@ -4,45 +4,85 @@ require 'md5'
 module Ramaze
   module Helper
     module HttpDigest
+
+      UUID_GENERATOR = UUID.new
+
+      SESSION_NONCE = 'httpdigest_authentication_nonce'
+      SESSION_OPAQUE = 'httpdigest_authentication_opaque'
+
+      def httpdigest_logout
+        session.delete( SESSION_NONCE )
+        session.delete( SESSION_OPAQUE )
+      end
+
+      def httpdigest_headers uid, realm
+        session[ SESSION_NONCE ] = UUID_GENERATOR.generate
+        session[ SESSION_OPAQUE ][ realm ][ uid ] = UUID_GENERATOR.generate
+        response['WWW-Authenticate'] =
+          %|Digest realm="#{realm}",| +
+          %|qop="auth,auth-int",| +
+          %|nonce="#{session[SESSION_NONCE]}",| +
+          %|opaque="#{session[SESSION_OPAQUE][realm][uid]}"|
+      end
+
       def httpdigest(uid, realm)
-        session_opaque = "authentication_digest_opaque_#{uid}"
-        session_nonce = "authentication_digest_nonce"
+        session[ SESSION_OPAQUE ] ||= {}
+        session[ SESSION_OPAQUE ][ realm ] ||= {}
+
+        if request.env['HTTP_AUTHORIZATION']
 
-        session[session_opaque] ||= UUID.new
+          authorized = false
 
-        authorized = false
+          if session[ SESSION_NONCE ] and session[ SESSION_OPAQUE ][ realm ][ uid ]
 
-        if session[session_nonce] and request.env['HTTP_AUTHORIZATION']
+            auth_split = request.env['HTTP_AUTHORIZATION'].split
+            authentication_type = auth_split[0]
+            authorization = Rack::Auth::Digest::Params.parse( auth_split[1..-1].join(' ') )
 
-          auth_split = request.env['HTTP_AUTHORIZATION'].split
-          authentication_type = auth_split[0]
-          authorization = Rack::Auth::Digest::Params.parse( auth_split[1..-1].join(' ') )
-          digest_response, username, nonce, nc, cnonce, qop =
-            authorization.values_at(*%w[response username nonce nc cnonce qop])
+            digest_response, username, nonce, nc, cnonce, qop, opaque =
+              authorization.values_at(*%w[response username nonce nc cnonce qop opaque])
 
-          if authentication_type == 'Digest'
-            if nonce == session[session_nonce]
-              ha1 = yield(username)
-              ha2 = MD5.hexdigest("#{request.request_method}:#{request.fullpath}")
-              md5 = MD5.hexdigest([ha1, nonce, nc, cnonce, qop, ha2].join(':'))
+            if authentication_type == 'Digest'
+              if nonce == session[SESSION_NONCE] and opaque == session[SESSION_OPAQUE][realm][uid]
+                h1 = nil
+                if respond_to?( :httpdigest_lookup_password )  
+                  ha1 = httpdigest_lookup_password( username )
+                else
+                  if respond_to?( :httpdigest_lookup_plaintext_password )
+                    ha1 = MD5.hexdigest( "#{username}:#{realm}:#{httpdigest_lookup_plaintext_password( username )}" )
+                  else
+                    if block_given?
+                      ha1 = yield( username )
+                    else
+                      raise "No password lookup handler found"
+                    end
+                  end
+                end
+                ha2 = MD5.hexdigest([request.request_method,request.fullpath].join(':'))
+                md5 = MD5.hexdigest([ha1, nonce, nc, cnonce, qop, ha2].join(':'))
 
-              authorized = digest_response == md5
+                authorized = digest_response == md5
+              end
             end
+
+          end
+
+          unless authorized
+            httpdigest_headers( uid, realm )
+            respond('Unauthorized', 401)
           end
-        end
 
-        unless authorized
-          session[session_nonce] = UUID.new
-          response['WWW-Authenticate'] =
-            %|Digest realm="#{realm}",| +
-            %|qop="auth,auth-int",| +
-            %|nonce="#{session[session_nonce]}",| +
-            %|opaque="#{session[session_opaque]}"|
+        else
+
+          httpdigest_headers( uid, realm )
+          httpdigest_failure if respond_to?( :httpdigest_failure )
           respond('Unauthorized', 401)
+
         end
 
         authorization["username"]
       end
+
     end
   end
 end

data/lib/ramaze/helper/paginate.rb

@@ -165,9 +165,8 @@ module Ramaze
           text = h(text.to_s)
 
           params = Ramaze::Request.current.params.merge(@var.to_s => n)
-          name = Ramaze::Action.stack.first.name
-          name = '/' if name == 'index' # make nicer...
-          hash[:href] = Rs(name, params)
+          name = Ramaze::Request.current.request_path
+          hash[:href] = R(name, params)
 
           g.a(hash){ text }
         end

data/lib/ramaze/helper/partial.rb

@@ -69,7 +69,7 @@ module Ramaze
       else
         roots = [options[:controller].template_paths].flatten
 
-        if (files = Dir["{#{roots.join(',')}}"/"{#{file},#{file}.*}"]).any?
+        if (files = Dir[File.join("{#{roots.join(',')}}","{#{file},#{file}.*}")]).any?
           options[:template] = files.first.squeeze '/'
         else
           Log.warn "render_template: #{file} does not exist in the following directories: #{roots.join(',')}."

data/lib/ramaze/helper/user.rb

@@ -8,10 +8,10 @@ module Ramaze
     #
     # class MainController < Ramaze::Controller
     #   def index
-    #     if user?
-    #       A('login', :href => Rs(:login))
-    #     else
+    #     if logged_in?
     #       "Hello #{user.name}"
+    #     else
+    #       A('login', :href => Rs(:login))
     #     end
     #   end
     #
@@ -77,7 +77,7 @@ module Ramaze
           elsif _model.respond_to?(:authenticate)
             _model.authenticate(creds)
           else
-            Log.warn("Helper::User has no callback and %p doesn't respond to #authenticate" % _model)
+            Log.warn("Helper::User has no callback and there is no %p::authenticate" % _model)
             nil
           end
         end

data/lib/ramaze/helper.rb

@@ -12,8 +12,9 @@ module Ramaze
   module Helper
     LOOKUP = Set.new
     PATH = ['']
+    path = File.expand_path("#{BASEDIR}/../spec/ramaze/helper/")
     trait :ignore => [
-      /#{Regexp.escape(File.expand_path(BASEDIR/'../spec/ramaze/helper/'))}\//
+      /#{Regexp.escape(path)}\//
     ]
 
     module Methods
@@ -61,7 +62,7 @@ module Ramaze
       end
 
       def require_helper(name)
-        paths = (PATH + [Global.root, BASEDIR/:ramaze]).join(',')
+        paths = (PATH + [Global.root, "#{BASEDIR}/ramaze"]).join(',')
         glob = "{#{paths}}/helper/#{name}.{so,bundle,rb}"
         files = Dir[glob]
         ignore = Helper.trait[:ignore]

data/lib/ramaze/log/rotatinginformer.rb

@@ -0,0 +1,168 @@
+module Ramaze
+  
+  module Logger
+
+    # A customized logger (based on Informer) that creates multiple log files based on time
+
+    class RotatingInformer
+      
+      include Logging
+
+      attr_accessor :time_format, :log_levels
+      attr_reader :base_dir
+      
+      # parameter for Time.now.strftime
+      trait :timestamp => "%Y-%m-%d %H:%M:%S"
+
+      # This is how the final output is arranged.
+      trait :format => "[%time] %prefix  %text"
+
+      # Create a new instance of RotatingInformer.
+      #
+      # base_dir is the directory where all log files will be stored
+      #
+      # time_format is the time format used to name the log files.
+      # Possible formats are identical to those
+      # accepted by Time.strftime
+      #
+      # log_levelse is an array describing what kind of messages
+      # that the log receives. The array may contain
+      # any or all of the symbols :debug, :error, :info and/or :warn
+      #
+      # Examples:
+      #   RotatingInformer.new('logs')
+      #                                   #=> Creates logs in directory called logs.
+      #                                       The generated filenames will be in the
+      #                                       form YYYY-MM-DD.log
+      #   RotatingInformer.new('logs', '%Y-%m.txt')
+      #                                   #=> Creates logs in directory called logs.
+      #                                       The generated filenames will be in the
+      #                                       form YYYY-MM.txt
+      #   RotatingInformer.new('logs', '%Y-%m.txt', [:error])
+      #                                   #=> Creates logs in directory called logs.
+      #                                       The generated filenames will be in the
+      #                                       form YYYY-MM.txt. Only errors will be
+      #                                       logged to the files.
+
+      def initialize(base_dir, time_format = '%Y-%m-%d.log', log_levels = [:debug, :error, :info, :warn])
+        # Verify and set base directory
+        send :base_dir=, base_dir, true
+        
+        @time_format = time_format
+        @log_levels = log_levels
+        
+        # Keep track of log shutdown (to prevent StackErrors due to recursion)
+        @in_shutdown = false
+      end
+
+      # Set the base directory for log files
+      # 
+      # If this method is called with the raise_exception
+      # parameter set to true the method will raise an exception
+      # if the specified directory does not exist or is unwritable.
+      # 
+      # If raise_exception is set to false, the method will just
+      # silently fail if the specified directory does not exist
+      # or is unwritable
+      
+      def base_dir=(directory, raise_exception = false)
+        # Expand directory path
+        base_dir = File.expand_path(directory)
+        # Verify that directory path exists
+        if File.exist?(base_dir)
+          # Verify that directory path is a directory
+          if File.directory?(base_dir)
+            # Verify that directory path is writable
+            if File.writable?(base_dir)
+              @base_dir = base_dir
+            else
+              raise Exception.new("#{base_dir} is not writable") if raise_exception
+            end
+          else
+            raise Exception.new("#{base_dir} is not a directory") if raise_exception
+          end
+        else
+          raise Exception.new("#{base_dir} does not exist.") if raise_exception
+        end
+      end
+      
+      # Close the file we log to if it isn't closed already.
+
+      def shutdown
+        if @out.respond_to?(:close)
+          unless @in_shutdown
+            @in_shutdown = true
+            Log.debug("close, #{@out.inspect}")
+            @in_shutdown = false
+          end
+          @out.close
+        end
+      end
+
+      # Integration to Logging.
+
+      def log tag, *messages
+
+        return unless @log_levels.include?(tag)
+
+        # Update current log
+        update_current_log       
+
+        messages.flatten!
+
+        prefix = tag.to_s.upcase.ljust(5)
+
+        messages.each do |message|
+          @out.puts(log_interpolate(prefix, message))
+        end
+
+        @out.flush if @out.respond_to?(:flush)
+      end
+
+      # Takes the prefix (tag), text and timestamp and applies it to
+      # the :format trait.
+
+      def log_interpolate prefix, text, time = timestamp
+        message = class_trait[:format].dup
+
+        vars = { '%time' => time, '%prefix' => prefix, '%text' => text }
+        vars.each{|from, to| message.gsub!(from, to) }
+
+        message
+      end
+
+      # This uses Global.inform_timestamp or a date in the format of
+      #   %Y-%m-%d %H:%M:%S
+      #   # => "2007-01-19 21:09:32"
+
+      def timestamp
+        mask = class_trait[:timestamp]
+        Time.now.strftime(mask || "%Y-%m-%d %H:%M:%S")
+      end
+
+      # is @out closed?
+
+      def closed?
+        @out.respond_to?(:closed?) && @out.closed?
+      end
+
+      private
+
+      # Checks whether current filename is still valid.
+      # If not, update the current log to point at the new
+      # filename
+
+      def update_current_log
+        out = File.join(@base_dir, Time.now.strftime(@time_format))
+        if @out.nil? || @out.path != out
+          # Close old log if necessary
+          shutdown unless @out.nil? || closed?
+
+          # Start new log
+          @out = File.open(out, 'ab+')
+        end
+      end
+    end
+
+  end
+end

data/lib/ramaze/option/holder.rb

@@ -78,7 +78,7 @@ module Ramaze
       # currently set one.
       def public_root
         [ @public_root,
-          root/@public_root
+          File.join(root, @public_root)
         ].find{|path| File.directory?(path) } || @public_root
       end
 
@@ -90,8 +90,8 @@ module Ramaze
       # the currently set one.
       def view_root
         [ @view_root,
-          root/@view_root,
-          root/'template',
+          File.join(root, @view_root),
+          File.join(root, 'template'),
         ].find{|path| File.directory?(path) } || @view_root
       end