Pistos-ramaze 2008.09

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,
+          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,
+          root/@view_root,
+          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

data/lib/ramaze/option.rb

@@ -0,0 +1,156 @@
+require 'ramaze/option/dsl'
+require 'ramaze/option/holder'
+
+module Ramaze
+  Global = Option::Holder.new
+
+  Option::DSL.new Global do
+    o "List of aliases for adapters",
+      :adapter_aliases, {
+        "mongrel"             => "Mongrel",
+        "evented_mongrel"     => "Mongrel",
+        "fcgi"                => "Fcgi",
+        "thin"                => "Thin",
+        "ebb"                 => "Ebb",
+        "cgi"                 => "Cgi",
+        "lsws"                => "LSWS",
+        "scgi"                => "SCGI",
+        "webrick"             => "WEBrick",
+        "swiftiplied_mongrel" => "Mongrel",
+      }
+
+    o "Hash of aliases for caches",
+      :cache_aliases, {
+        "memory"    => "MemoryCache",
+        "yaml"      => "YAMLStoreCache",
+        "memcache"  => "MemcachedCache",
+        "memcached" => "MemcachedCache",
+      }
+
+    o "Disable templates without actions",
+      :actionless_templates, true, :cli => true
+
+    o "Set adapter Ramaze will run on.",
+      :adapter, :webrick, :cli => @config[:adapter_aliases][1].keys, :short => :a
+
+    o "Set the size of Backtrace shown.",
+      :backtrace_size, 10, :cli => 10
+
+    o "Turn benchmarking every request on.",
+      :benchmarking, false, :short => :b, :cli => false
+
+    o "Do not log about these requests to static files, values as in Global.ignore",
+      :boring, ["/favicon.ico"]
+
+    o "Use this for general caching and as base for Cache.new.",
+      :cache, :memory, :cli => [:memory, :memcached, :yaml]
+
+    o "Turn on naive caching of all requests.",
+      :cache_all, false, :cli => false
+
+    o "Alternative caches",
+      :cache_alternative, {}
+
+    o "Don't cache action if session flash data is present for a request.",
+      :no_cache_flash, true, :cli => true
+
+    o "Compile Templates",
+      :compile, false, :cli => false
+
+    o "Start Ramaze within an IRB session",
+      :console, false, :short => :c
+
+    o "Active contribs",
+      :contribs, Set.new
+
+    o "Set default Content-Type for responses",
+      :content_type, "text/html"
+
+    o "Set default Accept-Charset for responses. No header set if nil.",
+      :accept_charset, nil
+
+    o "All subclasses of Controller are collected here.",
+      :controllers, Set.new
+
+    o "Instruction for daemonize, only works with bin/ramaze for now",
+      :daemonize, '', :cli => [:start, :stop]
+
+    o "Turn on customized error pages. Use Rack::ShowException otherwise.",
+      :error_page, true, :cli => true
+
+    o "Caching actions to the filesystem in Global.public_root",
+      :file_cache, false, :cli => false
+
+    o "Specify what IP Ramaze will respond to - 0.0.0.0 for all",
+      :host, "0.0.0.0", :cli => "0.0.0.0"
+
+    o "Ignore requests to these paths if no file in public_root exists, absolute path or regex",
+      :ignore, ["/favicon.ico"]
+
+    o "Body set on ignored paths",
+      :ignore_body, "File not found"
+
+    o "Status set on ignored paths",
+      :ignore_status, 404
+
+    o "Enable directory listing",
+      :list_directories, false
+
+    o "Templating engines to load on startup",
+      :load_engines, nil
+
+    o "All paths to controllers are mapped here.",
+      :mapping, {}
+
+    o "Activate middleware",
+      :middleware, true
+
+    o "For your own modes to decide on",
+      :mode, :live, :cli => [:live, :dev, :spec]
+
+    o "The place ramaze was started from, useful mostly for debugging",
+      :origin, :main
+
+    o "Specify port",
+      :port, 7000, :short => :p, :cli => 7000
+
+    o "Specify directory to serve static files",
+      :public_root, "public", :cli => "public"
+
+    o "Prefix for incoming and outgoing links",
+      :prefix, '/'
+
+    o "Record all Request objects by assigning a filtering Proc to me.",
+      :record, false
+
+    o "root directory of your application (former APPDIR)",
+      :root, File.dirname(File.expand_path($0))
+
+    o "Don't wait until all adapter-threads are finished or killed.",
+      :run_loose, false, :cli => false
+
+    o "The runner of your application (start.rb)",
+      :runner, "/home/manveru/c/ramaze/examples/hello.rb"
+
+    o "The running server will be put here from Adapter.",
+      :server, nil
+
+    o "Turn on session for all requests.",
+      :sessions, true, :cli => true
+
+    o "Turn on BF/DoS protection for error-responses",
+      :shield, false, :cli => false
+
+    o "What signal to trap to call Ramaze::shutdown",
+      :shutdown_trap, "SIGINT"
+
+    o "Interval in seconds of the Reloader",
+      :sourcereload, 3, :cli => 3
+
+    o "Test before start if adapters will be able to connect",
+      :test_connections, true, :cli => true
+
+    o "Specify directory to serve dynamic files",
+      :view_root, "view", :cli => "view"
+  end
+end