ramaze 0.1.1 → 0.1.2

data/lib/ramaze/inform.rb

@@ -5,8 +5,17 @@ require 'ramaze/inform/informing'
 require 'ramaze/inform/hub'
 require 'ramaze/inform/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::Informer.trait[:colorize] = false
+end
+
 module Ramaze
   autoload :Analogger, "ramaze/inform/analogger.rb"
+  autoload :Knotify,   "ramaze/inform/knotify.rb"
   autoload :Syslog,    "ramaze/inform/syslog.rb"
   autoload :Growl,     "ramaze/inform/growl.rb"
   autoload :Xosd,      "ramaze/inform/xosd.rb"

data/lib/ramaze/inform/hub.rb

@@ -1,14 +1,18 @@
 #          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
+require 'set'
+
 module Ramaze
   class LogHub
     include Informing
 
     attr_accessor :loggers
+    attr_accessor :ignored_tags
 
     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
@@ -18,6 +22,7 @@ module Ramaze
     end
 
     def inform(tag, *args)
+      return if @ignored_tags.include?(tag)
       @loggers.each do |logger|
         logger.inform(tag, *args)
       end

data/lib/ramaze/inform/informer.rb

@@ -5,7 +5,10 @@ module Ramaze
   class Informer
     include Informing
 
-    attr_accessor :colorize, :out
+    attr_accessor :out, :colorize
+
+    # Should Ramaze try to use colors?
+    trait :colorize => true
 
     # parameter for Time.now.strftime
     trait :timestamp => "%Y-%m-%d %H:%M:%S"
@@ -14,14 +17,16 @@ module Ramaze
     trait :format => "[%time] %prefix  %text"
 
     # Which tag should be in what color
-    trait :colors => {
+    COLORS = {
       :info  => :green,
       :debug => :yellow,
       :warn  => :red,
       :error => :red,
     }
 
-    def initialize(out = $stdout, colorize = nil)
+    def initialize(out = $stdout)
+      @colorize = false
+
       @out =
         case out
         when STDOUT, :stdout, 'stdout'
@@ -34,12 +39,13 @@ module Ramaze
           if out.respond_to?(:puts)
             out
           else
-            colorize = false
             File.open(out.to_s, 'ab+')
           end
         end
 
-      @colorize = @out.tty? rescue false if colorize.nil?
+      if @out.respond_to?(:tty?) and class_trait[:colorize]
+        @colorize = @out.tty?
+      end
     end
 
     def shutdown
@@ -56,7 +62,7 @@ module Ramaze
       prefix = tag.to_s.upcase.ljust(5)
 
       if @colorize
-        color = class_trait[:colors][tag] ||= :white
+        color = COLORS[tag] ||= :white
         prefix.replace prefix.send(color)
       end
 

data/lib/ramaze/inform/informing.rb

@@ -2,6 +2,18 @@
 # 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 Informing
+  #
+  #     def inform(tag, *args)
+  #       p tag => args
+  #     end
+  #   end
+
   module Informing
     def tag_inform(tag, meth, *strings)
       strings.each do |string|
@@ -10,24 +22,33 @@ module Ramaze
       end
     end
 
-    def info(*strings)
-      tag_inform(:info, :to_s, *strings)
+    # Converts everything given to strings and passes them on with :info
+
+    def info(*objects)
+      tag_inform(:info, :to_s, *objects)
     end
 
-    def warn(*strings)
-      tag_inform(:warn, :to_s, *strings)
+    # Converts everything given to strings and passes them on with :warn
+
+    def warn(*objects)
+      tag_inform(:warn, :to_s, *objects)
     end
 
-    def debug(*strings)
-      tag_inform(:debug, :inspect, *strings)
+    # inspects objects if they are no strings. Tag is :debug
+
+    def debug(*objects)
+      tag_inform(:debug, :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_inform :error
+
     def error(ex)
       if ex.respond_to?(:exception)
         message = ex.backtrace[0..Global.backtrace_size]
-        message.map!{|m| m.gsub(/^#{Dir.pwd}/, '.') }
+        message.map{|m| m.gsub!(/^#{Dir.pwd}/, '.') }
         message.unshift(ex.inspect)
       else
         message = ex.to_s
@@ -35,10 +56,14 @@ module Ramaze
       tag_inform(:error, :to_s, *message)
     end
 
+    # raises
+
     def inform(*args)
       raise "#inform should be implemented by an instance including this module (#{self})"
     end
 
+    # nothing
+
     def shutdown
     end
 

data/lib/ramaze/inform/knotify.rb

@@ -0,0 +1,21 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  class Knotify
+    include Informing
+
+    trait :present => 16
+
+    # Please see for more information:
+    # http://lukeplant.me.uk/articles.php?id=3
+    def inform(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

data/lib/ramaze/inform/xosd.rb

@@ -2,40 +2,74 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 require 'xosd'
+require 'thread'
 
 module Ramaze
 
   class Xosd < ::Xosd
-    include Informing
+    attr_accessor :options
 
-    trait :timeout => 3
-    trait :lines => 3
+    include Informing
 
-    trait :colors => {
-      :error => "#FF0000",
-      :info => "#00FF00",
-      :warn => "#EAA61E",
-      :debug => "#FFFFFF"
+    DEFAULT = {
+      :font_size       => 20,
+      :font            => "-*-*-*-*-*-*-%d-*-*-*-*-*-*-*",
+      :align           => 'center',
+      :color           => '#FFFFFF',
+      :lines           => 3,
+      :valign          => 'top',
+      :timeout         => 3,
+      :outline_color   => "#000000",
+      :outline_width   => 1,
+      :vertical_offset => 20,
+      :colors => {
+        :error => "#FF0000",
+        :info => "#00FF00",
+        :warn => "#EAA61E",
+        :debug => "#FFFF00"
+      },
     }
 
-    def initialize
-      super(class_trait[:lines])
-
-      self.font            = "-*-*-*-*-*-*-24-*-*-*-*-*-*-*"
-      self.align           = 'center'
-      self.color           = '#FFFFFF'
-      self.valign          = 'top'
-      self.timeout         = class_trait[:timeout]
-      self.outline_color   = "#000000"
-      self.outline_width   = 1
-      self.vertical_offset = 20
-    end
+    # keys to ignore when setting the options to the instance.
+    IGNORE = [:colors, :font_size, :lines]
+
+    # Here new messages are pushed to eventually displaying them.
+    QUEUE = Queue.new
+
+    def initialize(options = {})
+      @options = DEFAULT.merge(options)
+
+      super(@options[:lines])
 
-    def inform(tag, *args)
-      self.color = class_trait[:colors][tag.to_sym]
+      @options.each do |key, value|
+        next if IGNORE.include?(key)
+        value %= @options[:font_size] if key == :font
+        send("#{key}=", value)
+      end
+
+      Thread.new(self) do |xosd|
+        loop do
+          items = []
+          lines = xosd.options[:lines]
+          items << QUEUE.shift until QUEUE.empty? or items.size >= lines
+
+          unless items.empty?
+            # pad up with empty lines to avoid dragging around old messages.
+            items << [:info, ' '] until items.size >= lines
+
+            items.each_with_index do |(tag, message), i|
+              xosd.color = xosd.options[:colors][tag.to_sym]
+              xosd.display(message, i)
+            end
+          end
+          sleep xosd.options[:timeout]
+        end
+      end
+    end
 
-      args.each_with_index do |arg, i|
-        display(arg, i)
+    def inform(tag, *messages)
+      messages.each do |message|
+        QUEUE << [tag, message]
       end
     end
   end

data/lib/ramaze/sourcereload.rb

@@ -9,7 +9,8 @@ module Ramaze
 
     def initialize interval = 1, reload_glob = %r{(^\./)|#{Dir.pwd}|ramaze}
       @interval, @reload_glob = interval, reload_glob
-      @mtimes, @map = {}, []
+      @map, @files, @paths = [], [], []
+      @mtimes = {}
     end
 
     def start
@@ -45,6 +46,7 @@ module Ramaze
     #
 
     def reload
+      SourceReloadHooks.before_reload
       all_reload_files.each do |file|
         mtime = mtime(file)
 
@@ -53,6 +55,7 @@ module Ramaze
         Inform.debug("reload #{file}")
         @mtimes[file] = mtime if safe_load(file)
       end
+      SourceReloadHooks.after_reload
     end
 
     def all_reload_files
@@ -79,11 +82,37 @@ module Ramaze
     end
 
     def safe_load(file)
+      SourceReloadHooks.before_safe_load(file)
       load(file)
+      SourceReloadHooks.after_safe_load_succeed(file)
       true
     rescue Object => ex
       Inform.error(ex)
+      SourceReloadHooks.after_safe_load_failed(file, ex)
       false
     end
   end
+
+  # Holds hooks that are called before and after #reload and #safe_load
+
+  module SourceReloadHooks
+    module_function
+
+    def before_reload
+    end
+
+    def after_reload
+    end
+
+    def before_safe_load(file)
+    end
+
+    def after_safe_load_succeed(file)
+      Cache.compiled.clear
+      Cache.resolved.clear
+    end
+
+    def after_safe_load_failed(file, error)
+    end
+  end
 end

data/lib/ramaze/template.rb

@@ -7,31 +7,35 @@
 module Ramaze
   module Template
 
+    COMPILED = {} unless defined?(COMPILED)
+
+    # Place register_engine puts the class and extensions for templating engines
+
+    ENGINES = {} unless defined?(ENGINES)
+
     %w[ Amrita2 Erubis Haml Liquid Markaby Remarkably ].each do |const|
       autoload(const, "ramaze/template/#{const.downcase}")
     end
 
-    # The superclass for all templates, doesn't do much more than including
-    # Ramaze::Helper and defining #reaction_or_file
+    # The superclass for all templates, contains the shared behaviour of
+    # the templates and includes Ramaze::Helper
 
     class Template
       include Ramaze::Helper
 
       class << self
 
-        # pass it the results of the method of the controller
-        # and a possible file, it will see if the file is an actual file
+        # calls result_and_file with the given action and returns the first of
+        # the result of the controller or content of the file.
 
         def reaction_or_file action
-          reaction = render_method(action)
-
-          if file = action.template
-            File.read(file)
-          else
-            reaction.to_s
-          end
+          result_and_file(action).reverse.compact.first
         end
 
+        # Takes an Action and returns the result from sending the action.method
+        # to the controller via render_method and reads the contents of the file
+        # if given.
+
         def result_and_file(action)
           result = render_method(action)
 
@@ -42,9 +46,26 @@ module Ramaze
           [result, content]
         end
 
+        # returns nil if no method is on the action, otherwise it will send the
+        # action and optional parameters to the controller via __send__ and
+        # return the unaltered result
+
         def render_method(action)
           return unless method = action.method
-          action.controller.__send__(method, *action.params)
+          action.instance.__send__(method, *action.params)
+        end
+
+        # This is a wrapper to use Global.compile without even thinking about it.
+        # Don't use it if your engine is not based on a compile/eval principle.
+
+        def wrap_compile(action, template = nil)
+          template ||= reaction_or_file(action).to_s
+
+          if Global.compile
+            Cache.compiled[action.relaxed_hash] ||= compile(action, template)
+          else
+            compile(action, template)
+          end
         end
       end
     end

data/lib/ramaze/template/amrita2.rb

@@ -3,32 +3,33 @@
 
 require 'amrita2/template'
 
-module Ramaze::Template
+module Ramaze
+  module Template
+    # Is responsible for compiling a template using the Amrita2 templating engine.
 
-  # Is responsible for compiling a template using the Amrita2 templating engine.
+    class Amrita2 < Template
 
-  class Amrita2 < Template
+      ENGINES[self] = %w[ amrita amr ]
 
-    Ramaze::Controller.register_engine self, %w[ amrita ]
+      class << self
 
-    class << self
+        # Takes an Action
+        # The file is rendered using Amrita2::TemplateFile.
+        # The Controller is used as the object for expansion.
+        #
+        # The parameters are set to @params in the controller before expansion.
 
-      # Takes an Action
-      # The file is rendered using Amrita2::TemplateFile.
-      # The Controller is used as the object for expansion.
-      #
-      # The parameters are set to @params in the controller before expansion.
+        def transform action
+          instance, params, file =
+            action.instance, action.params, action.template
+          raise_no_action(action) unless file
 
-      def transform action
-        controller, params, file =
-          action.controller, action.params, action.template
-        raise_no_action(action) unless file
-
-        template = ::Amrita2::TemplateFile.new(file)
-        out = ''
-        controller.instance_variable_set('@params', params)
-        template.expand(out, controller)
-        out
+          template = ::Amrita2::TemplateFile.new(file)
+          out = ''
+          instance.instance_variable_set('@params', params)
+          template.expand(out, instance)
+          out
+        end
       end
     end
   end