ramaze 0.0.9 → 0.1.0

data/lib/ramaze/inform/hub.rb

@@ -0,0 +1,26 @@
+#          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 LogHub
+    include Informing
+
+    attr_accessor :loggers
+
+    def initialize(*loggers)
+      @loggers = loggers
+      @loggers.map! do |logger|
+        logger.is_a?(Class) ? logger.new : logger
+      end
+      @loggers.delete_if {|x| x == self }
+      @loggers.uniq!
+      @loggers.compact!
+    end
+
+    def inform(tag, *args)
+      @loggers.each do |logger|
+        logger.inform(tag, *args)
+      end
+    end
+  end
+end

data/lib/ramaze/inform/informer.rb

@@ -0,0 +1,92 @@
+#          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 Informer
+    include Informing
+
+    attr_accessor :colorize, :out
+
+    # 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
+    trait :colors => {
+      :info  => :green,
+      :debug => :yellow,
+      :warn  => :red,
+      :error => :red,
+    }
+
+    def initialize(out = $stdout, colorize = nil)
+      @out =
+        case out
+        when STDOUT, :stdout, 'stdout'
+          $stdout
+        when STDERR, :stderr, 'stderr'
+          $stderr
+        when IO
+          out
+        else
+          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?
+    end
+
+    def shutdown
+      if @out.respond_to?(:close)
+        Inform.debug("close, #{@out.inspect}")
+        @out.close
+      end
+    end
+
+    def inform tag, *messages
+      return if closed?
+      messages.flatten!
+
+      prefix = tag.to_s.upcase.ljust(5)
+
+      if @colorize
+        color = class_trait[: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
+
+    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
+
+    def closed?
+      @out.respond_to?(:closed?) and @out.closed?
+    end
+  end
+end

data/lib/ramaze/inform/informing.rb

@@ -0,0 +1,44 @@
+#          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
+  module Informing
+    def tag_inform(tag, meth, *strings)
+      strings.each do |string|
+        string = (string.respond_to?(:to_str) ? string : string.send(meth))
+        inform(tag, string)
+      end
+    end
+
+    def info(*strings)
+      tag_inform(:info, :to_s, *strings)
+    end
+
+    def warn(*strings)
+      tag_inform(:warn, :to_s, *strings)
+    end
+
+    def debug(*strings)
+      tag_inform(:debug, :inspect, *strings)
+    end
+
+    alias << debug
+
+    def error(ex)
+      if ex.respond_to?(:exception)
+        message = ex.backtrace[0..Global.backtrace_size]
+        message.unshift(ex.inspect)
+      else
+        message = ex.to_s
+      end
+      tag_inform(:error, :to_s, *message)
+    end
+
+    def inform(*args)
+      raise "#inform should be implemented by an instance including this module (#{self})"
+    end
+
+    def shutdown
+    end
+  end
+end

data/lib/ramaze/inform/syslog.rb

@@ -0,0 +1,27 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'syslog'
+
+module Ramaze
+  class Syslog
+    include ::Syslog
+
+    def initialize
+      open unless ::Syslog.opened?
+    end
+
+    alias error err
+    alias warn warning
+
+    def inform(tag, *args)
+      self.__send__(tag, *args)
+    end
+
+    public :error, :warn
+
+    def inspect
+      ::Syslog.inspect
+    end
+  end
+end

data/lib/ramaze/inform/xosd.rb

@@ -0,0 +1,42 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'xosd'
+
+module Ramaze
+
+  class Xosd < ::Xosd
+    include Informing
+
+    trait :timeout => 3
+    trait :lines => 3
+
+    trait :colors => {
+      :error => "#FF0000",
+      :info => "#00FF00",
+      :warn => "#EAA61E",
+      :debug => "#FFFFFF"
+    }
+
+    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
+
+    def inform(tag, *args)
+      self.color = class_trait[:colors][tag.to_sym]
+
+      args.each_with_index do |arg, i|
+        display(arg, i)
+      end
+    end
+  end
+end

data/lib/ramaze/snippets.rb

@@ -1,5 +1,9 @@
 #          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-require 'ramaze/snippets/kernel/aquire'
-aquire 'ramaze/snippets/*'
+dir  = File.join(File.expand_path(File.dirname(__FILE__)), 'snippets')
+glob = File.join(dir, '**', '*.rb')
+
+Dir[glob].each do |snippet|
+  require(snippet)
+end

data/lib/ramaze/snippets/object/traits.rb

@@ -54,7 +54,19 @@ class Object
   # {:three=>:drei, :two=>:zwei, :one=>:eins, :first=>:overwritten}
 
   def ancestral_trait
-    ancs = (ancestors rescue self.class.ancestors)
+    if respond_to?(:ancestors)
+      ancs = ancestors
+    else
+      ancs = self.class.ancestors
+    end
     ancs.reverse.inject({}){|s,v| s.merge(v.trait)}.merge(trait)
   end
+
+  def class_trait
+    if respond_to?(:ancestors)
+      trait
+    else
+      self.class.trait
+    end
+  end
 end

data/lib/ramaze/snippets/ramaze/autoreload.rb

@@ -5,6 +5,62 @@ require 'set'
 
 module Ramaze
 
+  RELOAD_ENV = {
+    :glob => /#{Dir.pwd}|ramaze/
+  }
+
+  class << self
+    def reload interval = 1
+      Inform.debug("initialize automatic file reload every #{interval} seconds")
+
+      Thread.new do
+        this = Thread.current
+        this[:task] = :autoreload
+
+        mtimes = {}
+
+        loop do
+          to_reload = all_reload_files.reject do |file|
+            mtime = File.mtime(file)
+            mtimes[file] ||= mtime
+            mtimes[file] == mtime
+          end
+
+          to_reload.each do |file|
+            sleep(interval / files.size.to_f)
+            Inform.debug("reload #{file}")
+            mtimes[file] = mtime if safe_load(file)
+          end
+        end
+      end
+    end
+
+    def all_reload_files
+      env = RELOAD_ENV
+
+      files, paths = $LOADED_FEATURES, $LOAD_PATH
+
+      unless env[:files] == files and env[:paths] == paths
+        env[:files], env[:paths] = files.dup, paths.dup
+        env[:map] = files.map do |file|
+          possible = paths.map{|pa| File.join(pa.to_s, file.to_s) }
+          possible.find{|po| File.exists?(po) }
+        end
+        env[:map] = env[:map].compact.sort
+      end
+
+      env[:map].select{|f| f =~ env[:glob] }
+    end
+
+    def safe_load(file)
+      load(file)
+      true
+    rescue Object => ex
+      Inform.error(ex)
+      false
+    end
+  end
+
   # this method loops through all loaded/required files
   # and re-loads them when they are updated.
   # It takes one parameter, which is the interval in seconds
@@ -13,7 +69,7 @@ module Ramaze
   # and it will just restart the autoreloader.
 
   def self.autoreload interval = 10
-    debug "initialize autoreload with an interval of #{interval} seconds"
+    Inform.debug("initialize autoreload with an interval of #{interval} seconds")
 
     gatherer = Thread.new do
       this = Thread.current
@@ -54,7 +110,7 @@ module Ramaze
             current_time = File.mtime(file)
             if last_time = cache[file]
               unless last_time == current_time
-                Ramaze::Informer.info "autoreload #{file}"
+                Inform.info("autoreload #{file}")
                 load(file)
                 cache[file] = current_time
               end

data/lib/ramaze/snippets/string/color.rb

@@ -0,0 +1,27 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+class String
+
+  {
+    :reset          =>  0,
+    :bold           =>  1,
+    :dark           =>  2,
+    :underline      =>  4,
+    :blink          =>  5,
+    :negative       =>  7,
+    :black          => 30,
+    :red            => 31,
+    :green          => 32,
+    :yellow         => 33,
+    :blue           => 34,
+    :magenta        => 35,
+    :cyan           => 36,
+    :white          => 37,
+  }.each do |key, value|
+    define_method key do
+      "\e[#{value}m" + self + "\e[0m"
+    end
+  end
+end
+

data/lib/ramaze/snippets/string/each.rb

@@ -0,0 +1,6 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+class String
+  alias each each_line unless ''.respond_to?(:each)
+end

data/lib/ramaze/snippets/struct/fill.rb

@@ -0,0 +1,15 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+class Struct
+
+  # Action = Struct.new('Action', :template, :method, :params)
+  #
+  # a = Action.fill(:template => nil, :method => :meth, :params => [1])
+  # # => #<struct Struct::Action template=nil, method=:meth, params=[1]>
+
+  def self.fill(hash = {})
+    values = hash.values_at(*members.map{|m| m.to_sym})
+    new(*values)
+  end
+end

data/lib/ramaze/template/ezamar.rb

@@ -39,14 +39,14 @@ module Ramaze
         # #pipeline
 
         def real_transform(controller, bound, file, action, *params)
-          alternate, path     = file_template(params.last, controller) if params.size == 1 and action == 'index'
-          file_template, path = file_template(file, controller)
-          ctrl_template       = render_action(controller, action, *params)
+          file_template = file_template(file)
+          ctrl_template = render_action(controller, action, *params)
 
-          if chosen = alternate || file_template || ctrl_template
-            pipeline(chosen, :binding => bound, :path => path)
+          if ctrl_template.respond_to?(:exception) and not file_template
+            raise ctrl_template
           else
-            raise_no_action(controller, action)
+            template = file_template || ctrl_template
+            pipeline(template, :binding => bound, :path => file)
           end
         end
 
@@ -54,27 +54,18 @@ module Ramaze
         #
         # Answers with the contents and otherwise nil
 
-        def file_template action_or_file, controller
-          path =
-            if File.file?(action_or_file)
-              action_or_file
-            else
-              Controller.find_template(action_or_file, controller)
-            end
-
-          return File.read(path), path
-        rescue
-          nil
+        def file_template file
+          return File.read(file) if file
+        rescue Errno::ENOENT => ex
+          Inform.error(ex)
         end
 
         # Render an action, on a given controller with parameter
 
         def render_action(controller, action, *params)
-          return controller.send(action, *params).to_s
-        rescue NoMethodError => ex
-          ourself = /undefined method `#{action}' for #<TCErrorController:/
-          raise_no_action(controller, action) unless ex.message =~ ourself
-          nil
+          controller.__send__(action, *params).to_s unless action.empty?
+        rescue => ex
+          ex
         end
 
         def raise_no_action(controller, action)