ramaze 0.3.9.1 → 2008.06

data/lib/ramaze/log/logger.rb

@@ -4,19 +4,25 @@
 require 'logger'
 
 module Ramaze
+  module Logging
+    module Logger
 
-  # Informer for the Stdlib Logger
+      # Informer for the Stdlib Logger
 
-  class Logger < ::Logger
+      class Logger < ::Logger
 
-    # integration to Logging
+        # integration to Logging
 
-    def log(tag, *args)
-      __send__(tag, args.join("\n"))
-    end
+        def log(tag, *args)
+          __send__(tag, args.join("\n"))
+        end
+
+        # Stub for compatibility
+        def dev(*args)
+          debug(*args)
+        end
+      end
 
-    def dev(*args)
-      debug(*args)
     end
   end
 end

data/lib/ramaze/log/logging.rb

@@ -2,87 +2,90 @@
 # 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)
+    # 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
-    end
 
-    # Converts everything given to strings and passes them on with :info
+      # Converts everything given to strings and passes them on with :info
 
-    def info(*objects)
-      tag_log(:info, :to_s, *objects)
-    end
+      def info(*objects)
+        tag_log(:info, :to_s, *objects)
+      end
 
-    # Converts everything given to strings and passes them on with :warn
+      # Converts everything given to strings and passes them on with :warn
 
-    def warn(*objects)
-      tag_log(:warn, :to_s, *objects)
-    end
+      def warn(*objects)
+        tag_log(:warn, :to_s, *objects)
+      end
 
-    # inspects objects if they are no strings. Tag is :debug
+      # inspects objects if they are no strings. Tag is :debug
 
-    def debug(*objects)
-      tag_log(:debug, :inspect, *objects)
-    end
+      def debug(*objects)
+        tag_log(:debug, :inspect, *objects)
+      end
 
-    # inspects objects if they are no strings. Tag is :dev
+      # inspects objects if they are no strings. Tag is :dev
 
-    def dev(*objects)
-      tag_log(:dev, :inspect, *objects)
-    end
+      def dev(*objects)
+        tag_log(:dev, :inspect, *objects)
+      end
 
-    alias << debug
+      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
+      # 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 || [])[0..Global.backtrace_size]
-        message.map{|m| m.gsub!(/^#{Regexp.escape(Dir.pwd)}/, '.') }
-        message.unshift(ex.inspect)
-      else
-        message = ex.to_s
+      def error(ex)
+        if ex.respond_to?(:exception)
+          message = [ex.backtrace].flatten[0..Global.backtrace_size]
+          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
-      tag_log(:error, :to_s, *message)
-    end
 
-    # raises
+      # raises
 
-    def log(*args)
-      raise "#log should be implemented by an instance including this module (#{self})"
-    end
+      def log(*args)
+        raise "#log should be implemented by an instance including this module (#{self})"
+      end
 
-    # nothing
+      # nothing
 
-    def shutdown
-    end
+      def shutdown
+      end
 
-    # stub for WEBrick
+      # stub for WEBrick
 
-    def debug?
-      false
+      def debug?
+        false
+      end
     end
+
   end
 end

data/lib/ramaze/log/syslog.rb

@@ -4,33 +4,38 @@
 require 'syslog'
 
 module Ramaze
+  module Logging
+    module Logger
 
-  # Informer for Syslog from rubys standard-library.
+      # Informer for Syslog from rubys standard-library.
 
-  class Syslog
-    include ::Syslog
+      class Syslog
+        include ::Syslog
 
-    # opens syslog
+        # opens syslog
 
-    def initialize
-      open unless ::Syslog.opened?
-    end
+        def initialize
+          open unless ::Syslog.opened?
+        end
 
-    # alias for default syslog methods so they match ramaze
-    alias error err
-    alias warn warning
-    alias dev debug
+        # alias for default syslog methods so they match ramaze
+        alias error err
+        alias warn warning
+        alias dev debug
 
-    # just sends all messages received to ::Syslog
-    def inform(tag, *args)
-      self.__send__(tag, *args)
-    end
+        # just sends all messages received to ::Syslog
+        def inform(tag, *args)
+          self.__send__(tag, *args)
+        end
+
+        public :error, :warn
 
-    public :error, :warn
+        # Has to call the modules singleton-method.
+        def inspect
+          ::Syslog.inspect
+        end
+      end
 
-    # Has to call the modules singleton-method.
-    def inspect
-      ::Syslog.inspect
     end
   end
 end

data/lib/ramaze/log/xosd.rb

@@ -1,88 +1,94 @@
 #          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 Logging
+    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
 
-  # 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)
+          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
-          sleep xosd.options[:timeout]
         end
-      end
-    end
 
-    # pushes all messages it gets on the QUEUE for further processing.
+        # pushes all messages it gets on the QUEUE for further processing.
 
-    def log(tag, *messages)
-      messages.each do |message|
-        QUEUE << [tag, message]
+        def log(tag, *messages)
+          messages.each do |message|
+            QUEUE << [tag, message]
+          end
+        end
       end
+
     end
   end
 end

data/lib/ramaze/option.rb

@@ -0,0 +1,153 @@
+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, 'start', :cli => [:start, :stop]
+
+    o "Turn on customized error pages.",
+      :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, false
+
+    o "For your own modes to decide on",
+      :mode, :live, :cli => [:live, :dev]
+
+    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 "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 background SourceReload",
+      :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