ptomato-ramaze 2009.02

data/lib/ramaze/log/syslog.rb

@@ -0,0 +1,51 @@
+#          Copyright (c) 2009 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

data/lib/ramaze/log/xosd.rb

@@ -0,0 +1,92 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+Ramaze::Log.log( :warn, "Both xosd gems are currently known to be broken" )
+require 'xosd'
+require 'thread'
+
+module Ramaze
+  module Logger
+
+    # Informer for the XOSD notification system for X11.
+    #
+    # You can install the ruby-bindings with:
+    #   gem install xosd.
+
+    class Xosd < ::Xosd
+      attr_accessor :options
+
+      include Logging
+
+      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"
+        },
+      }
+
+      # 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
+
+      # Create a new instance, valid options are in DEFAULT.
+      # In the background a new thread will be running that checks the QUEUE
+      # and processes all messages that are being sent to it.
+      # This is done to make output nicer and readable.
+
+      def initialize(options = {})
+        @options = DEFAULT.merge(options)
+
+        super(@options[:lines])
+
+        @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
+
+      # pushes all messages it gets on the QUEUE for further processing.
+
+      def log(tag, *messages)
+        messages.each do |message|
+          QUEUE << [tag, message]
+        end
+      end
+    end
+
+  end
+end

data/lib/ramaze/log.rb

@@ -0,0 +1,27 @@
+#          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/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.rb"
+  autoload :Knotify,   "ramaze/log/knotify.rb"
+  autoload :Syslog,    "ramaze/log/syslog.rb"
+  autoload :Growl,     "ramaze/log/growl.rb"
+  autoload :Xosd,      "ramaze/log/xosd.rb"
+  autoload :Logger,    "ramaze/log/logger.rb"
+
+  unless defined?(Log)
+    Log = Logger::LogHub.new(Logger::Informer)
+  end
+end

data/lib/ramaze/option/dsl.rb

@@ -0,0 +1,45 @@
+#          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 Option
+    class DSL
+      attr_reader :holder
+
+      def initialize(holder, &block)
+        @holder = holder
+        @config = {}
+        instance_eval(&block) if block_given?
+      end
+
+      def o(doc, key, value, options = {})
+        @config[key] = [doc, value, options]
+
+        holder.add_option(key, value, complain = false)
+        holder.trait[key] = options.merge(:doc => doc)
+      end
+
+      # to generate a new sorted source file from the config, was only used to
+      # merge new and old DSL.
+      def output
+        @config.keys.sort_by{|k,v| k.to_s }.each do |key|
+          doc, value, options = @config[key]
+          puts "o %s," % doc.dump
+
+          if options.empty?
+            puts "  %p, %p" % [key, value]
+          else
+            format = options.map{|(k,v)| '%p => %p' % [k,v]}.join(', ')
+            puts "  %p, %p, %s" % [key, value, format]
+          end
+
+          puts
+        end
+      end
+    end
+
+    def self.dsl(&block)
+      Option::DSL.new(&block)
+    end
+  end
+end

data/lib/ramaze/option/holder.rb

@@ -0,0 +1,131 @@
+#          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/option/merger'
+
+module Ramaze
+  module Option
+    class Holder
+      include Merger
+
+      def initialize(options = {})
+        @members = Set.new
+
+        options.each do |key, value|
+          add_option(key, value, complain = false)
+        end
+      end
+
+      def add_option(key, value, complain = true)
+        Log.warn("Adding #{key} to #{self}") if complain
+
+        self.class.class_eval do
+          attr_reader key unless method_defined?(key)
+          attr_writer key unless method_defined?("#{key}=")
+        end
+
+        self[key] = value
+      end
+
+      def [](key)
+        __send__(key)
+      end
+
+      def []=(key, value)
+        @members << key.to_s.to_sym
+        __send__("#{key}=", value)
+      end
+
+      include Enumerable
+
+      def each
+        @members.each do |member|
+          yield member, self[member]
+        end
+      end
+
+      def startup(options)
+        options.each do |key, value|
+          self[key] = value
+        end
+
+        merge!(ARGV)
+        merge!(ENV)
+
+        self.root ||= File.dirname(File.expand_path(runner))
+        [self.load_engines].flatten.compact.each do |engine|
+          Ramaze::Template.const_get(engine)
+        end
+      end
+
+      # batch-assignment of key/value from hash, yields self if a block is given.
+      def setup(hash = {})
+        merge!(hash)
+        yield(self) if block_given?
+      end
+
+      # Modified options
+
+      def port=(number)
+        @port = number.to_i
+      end
+
+      def public_root=(pr)
+        @public_root = pr
+      end
+
+      # Find a suitable public_root, if none of these is a directory just use the
+      # currently set one.
+      def public_root
+        [ @public_root,
+          File.join(root, @public_root)
+        ].find{|path| File.directory?(path) } || @public_root
+      end
+
+      def view_root=(vr)
+        @view_root = vr
+      end
+
+      # Find a suitable view_root, if none of these is a directory just use
+      # the currently set one.
+      def view_root
+        [ @view_root,
+          File.join(root, @view_root),
+          File.join(root, 'template'),
+        ].find{|path| File.directory?(path) } || @view_root
+      end
+
+      def adapter
+        find_from_aliases(@adapter, :adapter_aliases, Ramaze::Adapter, "ramaze/adapter")
+      end
+
+      def cache
+        find_from_aliases(@cache, :cache_aliases, Ramaze, "ramaze/cache")
+      end
+
+      def sourcereload=(interval)
+        Ramaze::Reloader::OPTIONS[:cooldown] = interval
+      end
+
+      private
+
+      def find_from_aliases(name, alias_key, mod, path)
+        case name
+        when String, Symbol
+          name = name.to_s
+          class_name = self[alias_key][name] || name
+          find_require(name, class_name, mod, path)
+        else
+          name
+        end
+      end
+
+      def find_require(name, class_name, mod, path)
+        file_path = File.join(path, name)
+        require(file_path) unless mod.const_defined?(class_name)
+
+        mod.const_get(class_name)
+      end
+    end
+  end
+end

data/lib/ramaze/option/merger.rb

@@ -0,0 +1,108 @@
+module Ramaze
+  module Option
+    module Merger
+
+      # Pass it anything that may work as option: ENV, hashes, ARGV...
+      # it will figure out how to get config from it and modify Global.
+      def merge!(obj, &block)
+        case obj
+        when ENV
+          merge_prefixed!(obj)
+        else
+          if obj.respond_to?(:each_pair)
+            obj.each_pair do |key, value|
+              self[key] = value
+            end
+          elsif obj.respond_to?(:each)
+            merge_cli!(obj, &block)
+          end
+        end
+
+        self
+      end
+
+      # Prefixed options, mostly useful for filtering out from ENV.
+      # by default the prefix is case-insensitive and set to ramaze_ - that
+      # works for keys like:
+      #     $ RAMAZE_PORT=80 ruby start.rb
+      #     $ ramaze_port=80 ruby start.rb
+      #     $ Ramaze_Port=80 ruby start.rb
+      def merge_prefixed!(obj, prefix = 'ramaze_')
+        opts = {}
+        obj.each do |key, value|
+          next unless key =~ /^#{prefix}(.*)/i
+          opts[$1.downcase] = value
+        end
+        merge! opts
+      end
+
+      # Only destructive for now, should non-destructive keep both Global and
+      # the obj original?
+
+      def merge_cli!(obj, &block)
+        option_parser(&block).parse!(obj)
+      end
+
+      def option_parser(bin = 'ramaze')
+        require 'optparse'
+        require 'abbrev'
+
+        OptionParser.new{|opt|
+          ruby_version = "ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
+          ramaze_version = "Ramaze Version #{VERSION}"
+          version = "#{ramaze_version}, on #{ruby_version}"
+
+          opt.banner = "Usage: #{bin} start.rb [OPTIONS]"
+          opt.define_head version
+
+          yield(opt) if block_given?
+
+          opt.separator ''
+          opt.separator 'Global options, value in [] shows default.'
+
+          Global.each do |key, value|
+            long_option = "--#{key}"
+            options = Global.trait.fetch(key, {})
+            doc, cli, short = options.values_at(:doc, :cli, :short)
+            short_option = "-#{short}" if short
+
+            next unless cli or short
+
+            case cli || value
+            when Integer
+              option = [short_option, "#{long_option} NUM", Integer, doc]
+            when String, Symbol
+              option = [short_option, "#{long_option} STRING", String, doc]
+            when Array
+              next unless cli
+              cli = cli.map{|c| c.to_s }
+              list = "  " << cli.join(', ')
+              doc = "[#{value}] #{doc}"
+              aliases = cli.abbrev
+              option = [short_option, "#{long_option} CHOICE", cli, doc, list]
+            else
+              option = [short_option, long_option, doc]
+            end
+
+            option.delete(nil)
+
+            opt.on(*option){|o| Ramaze::Global[key] = o }
+          end
+
+          opt.separator ''
+          opt.separator 'Common options:'
+
+          opt.on('-h', '--help', 'Show this message') do
+            puts opt
+            exit
+          end
+
+          opt.on('-v', '--version', "Show version") do
+            puts version
+            exit
+          end
+        }
+      end
+    end
+  end
+end