rjspotter-ramaze 2009.06.29

data/lib/ramaze/helper/xhtml.rb

@@ -0,0 +1,34 @@
+module Ramaze
+  module Helper
+
+    # Provides shortcuts to the link/script tags.
+    module XHTML
+      LINK_TAG = '<link href=%p media=%p rel="stylesheet" type="text/css" />'
+      SCRIPT_TAG = '<script src=%p type="text/javascript"></script>'
+
+      def css(name, media = 'screen', options = {})
+        if options.empty?
+          LINK_TAG % ["/css/#{name}.css", media]
+        elsif options[:only].to_s.downcase == 'ie'
+          "<!--[if IE]>#{css(name, media)}<![endif]-->"
+        end
+      end
+
+      def css_for(*args)
+        args.map{|arg| css(*arg) }.join("\n")
+      end
+
+      def js(name)
+        if name =~ /^http/ # consider it external full url
+          SCRIPT_TAG % name
+        else
+          SCRIPT_TAG % "/js/#{name}.js"
+        end
+      end
+
+      def js_for(*args)
+        args.map{|arg| js(*arg) }.join("\n")
+      end
+    end
+  end
+end

data/lib/ramaze/log.rb

@@ -0,0 +1,39 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'ramaze/log/logging'
+
+module Ramaze
+  Log = Innate::Log
+
+  module Logger
+    autoload :Analogger, 'ramaze/log/analogger'
+  end
+end
+
+__END__
+
+require 'ramaze/log/logging'
+require 'ramaze/log/hub'
+require 'ramaze/log/informer'
+
+begin
+  require 'win32console' if RUBY_PLATFORM =~ /win32/i
+rescue LoadError => ex
+  puts ex
+  puts "For nice colors on windows, please `gem install win32console`"
+  Ramaze::Logger::Informer.trait[:colorize] = false
+end
+
+module Ramaze
+  autoload :Analogger, "ramaze/log/analogger"
+  autoload :Knotify,   "ramaze/log/knotify"
+  autoload :Syslog,    "ramaze/log/syslog"
+  autoload :Growl,     "ramaze/log/growl"
+  autoload :Xosd,      "ramaze/log/xosd"
+  autoload :Logger,    "ramaze/log/logger"
+
+  unless defined?(Log)
+    Log = Logger::LogHub.new(Logger::Informer)
+  end
+end

data/lib/ramaze/log/analogger.rb

@@ -0,0 +1,39 @@
+#          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)
+        super(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,129 @@
+#          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
+      include Ramaze::Traited
+
+      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,83 @@
+#          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
+        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
+
+    # nothing
+
+    def shutdown
+    end
+
+    # stub for WEBrick
+
+    def debug?
+      false
+    end
+  end
+
+end