Pistos-ramaze 2008.09

data/lib/ramaze/helper/ultraviolet.rb

@@ -0,0 +1,44 @@
+module Ramaze
+  module Helper
+    module Ultraviolet
+      trait :ultraviolet => {
+        :output       => 'xhtml',
+        :syntax       => nil, # syntax_name, nil|false indicates automatic detection
+        :line_numbers => false,
+        :style        => 'classic', # render_style
+        :headers      => false, # ouput document with all headers
+      }
+
+      # Parse and output the file at the given path.
+      # Please head over to the Ultraviolet documentation for more information
+      # on possible options.
+      def ultraviolet(path, options = {})
+        o = ancestral_trait[:ultraviolet].merge(options)
+        output, syntax, lines, style, headers =
+          o.values_at(:output, :syntax, :line_numbers, :style, :headers)
+
+        syntax ||= Uv.syntax_for_file(path).first.first
+        code = File.read(path)
+
+        p [code, output, syntax, lines, style, headers]
+        Uv.parse(code, output, syntax, lines, style, headers)
+      end
+
+      # Return absolute path to the css of given name.
+      #
+      # Usually this will point to somewhere in the gem tree.
+      #
+      # It seems like Uv will add support for user-defined PATH in the future,
+      # so we will, to be future-proof, traverse the Uv.path even though it
+      # currently will only have one directory.
+
+      def ultraviolet_css(theme)
+        Uv.path.each do |path|
+          Dir[path/"render/xhtml/files/css/*.css"].each do |css|
+            return css if File.basename(css, '.css') == theme
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/helper/user.rb

@@ -0,0 +1,110 @@
+module Ramaze
+  module Helper
+
+    # This helper provides a convenience wrapper for handling authentication
+    # and persistence of users.
+    #
+    # Example:
+    #
+    # class MainController < Ramaze::Controller
+    #   def index
+    #     if user?
+    #       A('login', :href => Rs(:login))
+    #     else
+    #       "Hello #{user.name}"
+    #     end
+    #   end
+    #
+    #   def login
+    #     user_login if reuqest.post?
+    #   end
+    # end
+
+    module User
+      # return existing or instantiate User::Wrapper
+      def user
+        model = ancestral_trait[:user_model] ||= ::User
+        callback = ancestral_trait[:user_callback] ||= nil
+        STATE[:user] ||= Wrapper.new(model, callback)
+      end
+
+      # shortcut for user.user_login but default argument are request.params
+
+      def user_login(creds = request.params)
+        user._login(creds)
+      end
+
+      # shortcut for user.user_logout
+
+      def user_logout
+        user._logout
+      end
+
+      def logged_in?
+        user._logged_in?
+      end
+
+      # Wrapper for the ever-present "user" in your application.
+      # It wraps around an arbitrary instance and worries about authentication
+      # and storing information about the user in the session.
+      #
+      # In order to not interfere with the wrapped instance/model we start our
+      # methods with an underscore.
+      # Suggestions on improvements as usual welcome.
+      class Wrapper < BlankSlate
+        attr_accessor :_model, :_callback, :_user
+
+        def initialize(model, callback)
+          @_model, @_callback = model, callback
+          @_user = nil
+          _login
+        end
+
+        def _login(creds = _persistence)
+          if @_user = _would_login?(creds)
+            self._persistence = creds
+          end
+        end
+
+        # The callback should return an instance of the user, otherwise it
+        # should answer with nil.
+        #
+        # This will not actually login, just check whether the credentials
+        # would result in a user.
+        def _would_login?(creds)
+          if c = @_callback
+            c.call(creds)
+          elsif _model.respond_to?(:authenticate)
+            _model.authenticate(creds)
+          else
+            Log.warn("Helper::User has no callback and %p doesn't respond to #authenticate" % _model)
+            nil
+          end
+        end
+
+        def _logout
+          _persistence.clear
+          STATE[:user] = nil
+        end
+
+        def _logged_in?
+          !!_user
+        end
+
+        def _persistence=(creds)
+          Current.session[:USER] = creds
+        end
+
+        def _persistence
+          Current.session[:USER] || {}
+        end
+
+        # Refer everything not known
+        def method_missing(meth, *args, &block)
+          return unless _user
+          _user.send(meth, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/helper/xhtml.rb

@@ -0,0 +1,23 @@
+module Ramaze::Helper
+  module XHTML
+    def css(name, media = 'screen', options = {})
+      if options.empty?
+        "<link rel='stylesheet' href='/css/#{name}.css' type='text/css' media='#{media}' />"
+      elsif options[:only] == 'IE'
+        "<!--[if IE]>#{css(name, media)}<![endif]-->"
+      end
+    end
+
+    def css_for(*names)
+      names.flatten.map{|name| css(name) }.join("\n")
+    end
+
+    def js(name)
+      "<script src='/js/#{name}.js' type='text/javascript'></script>"
+    end
+
+    def js_for(*names)
+      names.flatten.map{|name| js(name) }.join("\n")
+    end
+  end
+end

data/lib/ramaze/helper.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 'ramaze/trinity'
+
+module Ramaze
+
+  # A module used by the Templates and the Controllers
+  # it provides both Ramaze::Trinity (request/response/session)
+  # and also a helper method, look below for more information about it
+
+  module Helper
+    LOOKUP = Set.new
+    PATH = ['']
+    trait :ignore => [
+      /#{Regexp.escape(File.expand_path(BASEDIR/'../spec/ramaze/helper/'))}\//
+    ]
+
+    module Methods
+      def self.included other
+        other.send :extend, Trinity
+        other.send :extend, Methods
+        other.send :include, Trinity
+        super
+      end
+
+      def self.extend_object other
+        other.send :extend, Trinity
+        super
+      end
+
+      # This loads the helper-files from /ramaze/helper/helpername.rb and
+      # includes it into Ramaze::Template (or wherever it is called)
+      #
+      # Usage:
+      #   helper :redirect, :link
+
+      def helper(*syms)
+        syms.each do |sym|
+          name = sym.to_s
+          if mod = find_helper(name)
+            use_helper(mod)
+          else
+            if require_helper(name)
+              redo
+            else
+              raise LoadError, "#{name} not found"
+            end
+          end
+        end
+      end
+
+      private
+
+      def find_helper(name)
+        name = name.to_s.camel_case
+        ramaze_helper_consts = ::Ramaze::Helper.constants.grep(/^#{name}$/i)
+        if mod_name = ramaze_helper_consts.first
+          ::Ramaze::Helper.const_get(mod_name)
+        end
+      end
+
+      def require_helper(name)
+        paths = (PATH + [Global.root, BASEDIR/:ramaze]).join(',')
+        glob = "{#{paths}}/helper/#{name}.{so,bundle,rb}"
+        files = Dir[glob]
+        ignore = Helper.trait[:ignore]
+        files.reject!{|f| ignore.any?{|i| f =~ i }}
+        raise LoadError, "#{name} not found" unless file = files.first
+        require(file)
+      end
+
+      def use_helper(mod)
+        include mod
+        extend mod
+      end
+    end
+  end
+end

data/lib/ramaze/log/analogger.rb

@@ -0,0 +1,40 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'swiftcore/Analogger/Client'
+
+module Ramaze
+  module Logger
+
+    # Informer for the Swiftcore Analogger logging system.
+    #
+    # You can find it at http://analogger.swiftcore.org and install with
+    # gem install analogger
+
+    class Analogger < ::Swiftcore::Analogger::Client
+      include Logging
+
+      # identifier for your application
+      trait :name => 'walrus'
+
+      # Host analogger runs on
+      trait :host => '127.0.0.1'
+
+      # Port analogger runs on
+      trait :port => 6766
+
+      # Create a new instance, parameters default to the traits.
+
+      def initialize(name = class_trait[:name], host = class_trait[:host], port = class_trait[:port])
+        super
+      end
+
+      # integration to Logging
+
+      def log(tag, *args)
+        log(tag, args.join("\n"))
+      end
+    end
+
+  end
+end

data/lib/ramaze/log/growl.rb

@@ -0,0 +1,38 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'ruby-growl'
+
+module Ramaze
+  module Logger
+
+    # Informer for the growl notification system on OSX.
+
+    class Growl < ::Growl
+
+      trait :defaults => {
+        :name => 'walrus',
+        :host => 'localhost',
+        :password => 'walrus',
+        :all_notifies => %w[error warn debug info dev],
+        :default_notifies => %w[error warn info]
+      }
+
+      # Takes the options from the default trait for merging.
+
+      def initialize(options = {})
+        options = class_trait[:defaults].merge(options).values_at(:host, :name, :all_notifies, :default_notifies, :password)
+        super(*options)
+      end
+
+      # integration to Logging
+
+      def log(tag, *args)
+        notify(tag.to_s, Time.now.strftime("%X"), args.join("\n")[0..100])
+      rescue Errno::EMSGSIZE
+        # Send size was to big (not really), ignore
+      end
+    end
+
+  end
+end

data/lib/ramaze/log/hub.rb

@@ -0,0 +1,41 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module Logger
+
+    # Bundles different informer instances and sends incoming messages to each.
+    # This is the default with Informer as only member.
+
+    class LogHub
+      include Logging
+
+      attr_accessor :loggers
+      attr_accessor :ignored_tags
+
+      # Takes a list of instances or classes (which will be initialized) and that
+      # are added to @loggers. All messages are then sent to each member.
+
+      def initialize(*loggers)
+        @loggers = loggers
+        @ignored_tags = Set.new
+        @loggers.map! do |logger|
+          next(nil) if logger == self
+          logger.is_a?(Class) ? logger.new : logger
+        end
+        @loggers.uniq!
+        @loggers.compact!
+      end
+
+      # integration to Logging
+
+      def log(tag, *args)
+        return if @ignored_tags.include?(tag)
+        @loggers.each do |logger|
+          logger.log(tag, *args)
+        end
+      end
+    end
+
+  end
+end

data/lib/ramaze/log/informer.rb

@@ -0,0 +1,128 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module Logger
+
+    # A minimal logger for Ramaze, supports files, CLI, colors and some
+    # customization.
+
+    class Informer
+      include Logging
+
+      attr_accessor :out, :colorize, :log_levels
+
+      # Should Ramaze try to use colors?
+      trait :colorize => true
+
+      # 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"
+
+      # Which tag should be in what color
+      COLORS = {
+        :dev   => :blue,
+        :debug => :yellow,
+        :info  => :green,
+        :warn  => :red,
+        :error => :red,
+      }
+
+      # Create a new instance of Informer.
+      # You can spcify
+      #
+      # Examples:
+      #   Informer.new                    #=> logs to stdout with all levels being
+      #                                       shown.
+      #   Informer.new($stderr)           #=> same, but to stderr
+      #   Informer.new("foo.log")         #=> same, but logs to the file foo.log
+      #                                       (or creates it if it doesn't exist yet)
+      #   Informer.new($stdout, [:info])  #=> show only #info messages to stdout.
+
+      def initialize(out = $stdout, log_levels = [:debug, :error, :info, :warn])
+        @colorize = false
+
+        @out =
+          case out
+          when STDOUT, :stdout, 'stdout'
+            $stdout
+          when STDERR, :stderr, 'stderr'
+            $stderr
+          when IO
+            out
+          else
+            if out.respond_to?(:puts)
+              out
+            else
+              File.open(out.to_s, 'ab+')
+            end
+          end
+
+        if @out.respond_to?(:tty?) and class_trait[:colorize]
+          @colorize = @out.tty?
+        end
+
+        @log_levels = log_levels
+      end
+
+      # Close the file we log to if it isn't closed already.
+
+      def shutdown
+        if @out.respond_to?(:close)
+          Log.debug("close, #{@out.inspect}")
+          @out.close
+        end
+      end
+
+      # Integration to Logging.
+
+      def log tag, *messages
+        return if closed? || !@log_levels.include?(tag)
+        messages.flatten!
+
+        prefix = tag.to_s.upcase.ljust(5)
+
+        if @colorize
+          color = COLORS[tag] ||= :white
+          prefix.replace prefix.send(color)
+        end
+
+        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?) and @out.closed?
+      end
+    end
+
+  end
+end

data/lib/ramaze/log/knotify.rb

@@ -0,0 +1,28 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module Logger
+
+    # Informer for the Knotify notfication system used on KDE.
+    # Doesn't need any special libraries.
+
+    class Knotify
+      include Logging
+
+      trait :present => 16
+
+      # Please see for more information on the API used here:
+      # http://lukeplant.me.uk/articles.php?id=3
+
+      def log(tag, *messages)
+        present = class_trait[:present]
+        tag = tag.to_s.capitalize
+        messages.flatten.each do |message|
+          system(%{dcop knotify default notify Ramaze "#{tag}" "#{message}" '' '' #{present} 0})
+        end
+      end
+    end
+
+  end
+end

data/lib/ramaze/log/logger.rb

@@ -0,0 +1,26 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'logger'
+
+module Ramaze
+  module Logger
+
+    # Informer for the Stdlib Logger
+
+    class Logger < ::Logger
+
+      # integration to Logging
+
+      def log(tag, *args)
+        __send__(tag, args.join("\n"))
+      end
+
+      # Stub for compatibility
+      def dev(*args)
+        debug(*args)
+      end
+    end
+
+  end
+end

data/lib/ramaze/log/logging.rb

@@ -0,0 +1,89 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  # This module provides a basic skeleton for your own loggers to be compatible.
+  # The minimal usage is like this:
+  #
+  #   class MyLogger
+  #     include Logging
+  #
+  #     def log(tag, *args)
+  #       p tag => args
+  #     end
+  #   end
+
+  module Logging
+
+    # Takes the tag (:warn|:debug|:error|:info) and the name of a method to be
+    # called upon elements of msgs that don't respond to :to_str
+    # Goes on and sends the tag and transformed messages each to the #log method.
+    # If you include this module you have to define #log or it will raise.
+
+    def tag_log(tag, meth, *msgs)
+      msgs.each do |msg|
+        string = (msg.respond_to?(:to_str) ? msg : msg.send(meth))
+        log(tag, string)
+      end
+    end
+
+    # Converts everything given to strings and passes them on with :info
+
+    def info(*objects)
+      tag_log(:info, :to_s, *objects)
+    end
+
+    # Converts everything given to strings and passes them on with :warn
+
+    def warn(*objects)
+      tag_log(:warn, :to_s, *objects)
+    end
+
+    # inspects objects if they are no strings. Tag is :debug
+
+    def debug(*objects)
+      tag_log(:debug, :inspect, *objects)
+    end
+
+    # inspects objects if they are no strings. Tag is :dev
+
+    def dev(*objects)
+      tag_log(:dev, :inspect, *objects)
+    end
+
+    alias << debug
+
+    # Takes either an Exception or just a String, formats backtraces to be a bit
+    # more readable and passes all of this on to tag_log :error
+
+    def error(ex)
+      if ex.respond_to?(:exception)
+        message = [ex.backtrace].flatten[0..Global.backtrace_size]
+        message.map{|m| m.to_s.gsub(/^#{Regexp.escape(Dir.pwd)}/, '.') }
+        message.unshift(ex.inspect)
+      else
+        message = ex.to_s
+      end
+      tag_log(:error, :to_s, *message)
+    end
+
+    # raises
+
+    def log(*args)
+      raise "#log should be implemented by an instance including this module (#{self})"
+    end
+
+    # nothing
+
+    def shutdown
+    end
+
+    # stub for WEBrick
+
+    def debug?
+      false
+    end
+  end
+
+end

data/lib/ramaze/log/syslog.rb

@@ -0,0 +1,51 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+#          Copyright (c) 2008 rob@rebeltechnologies.nl
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'syslog'
+
+# Add aliases for the levelnames used by Ramaze logging
+module Syslog
+    alias dev debug
+    alias warn warning
+    alias error err
+    module_function :dev, :warn, :error 
+end
+
+module Ramaze
+    module Logger
+        # Logger class for writing to syslog. It is a *very* thin wrapper
+        # around the Syslog library.
+        class Syslog
+		    include Logging
+
+            # Open the syslog library, if it is allready open, we reopen it using the
+            # new argument list.  The argument list is passed on to the Syslog library
+            # so please check that, and man syslog for detailed information.  
+            # There are 3 parameters:
+            #
+            #   ident:  The identification used in the log file, defaults to $0
+            #   options:  defaults to  Syslog::LOG_PID | Syslog::LOG_CONS
+            #   facility: defaults to Syslog::LOG_USER
+            #
+            def initialize( *args )
+	    	    ::Syslog.close if ::Syslog.opened?
+	    	    ::Syslog.open( *args )
+            end
+
+            # just sends all messages received to ::Syslog
+            # We simply return if the log was closed for some reason, this behavior
+            # was copied from Informer.  We do not handle levels here. This will
+            # be done by te syslog daemon based on it's configuration.
+            def log(tag, *messages)
+			    return if !::Syslog.opened?
+              	::Syslog.send(tag, *messages)
+            end
+
+            # Has to call the modules singleton-method.
+            def inspect
+              ::Syslog.inspect
+            end
+        end
+    end
+end