ramaze 0.3.9.1 → 2008.06

data/lib/ramaze/adapter/cgi.rb

@@ -7,17 +7,12 @@ module Ramaze
   module Adapter
     # Our CGI adapter acts as wrapper for the Rack::Handler::CGI.
     class Cgi < Base
-      class << self
 
-        # start CGI in a new thread, host and port parameter are only taken
-        # to make it compatible with other adapters but have no influence and
-        # can be omitted
-        def start host = nil, ports = nil
-          Thread.new do
-            Thread.current[:task] = :cgi
-            Rack::Handler::CGI.run(self)
-          end
-        end
+      # start CGI in a new thread, host and port parameter are only taken
+      # to make it compatible with other adapters but have no influence and
+      # can be omitted
+      def self.startup(host = nil, port = nil)
+        Thread.new{ Rack::Handler::CGI.run(self) }
       end
     end
   end

data/lib/ramaze/adapter/ebb.rb

@@ -3,29 +3,15 @@ require 'ebb'
 module Ramaze
   module Adapter
     class Ebb < Base
-      class << self
-
-        # start server on given host and port.
-        def run_server host, port
-          server = ::Ebb::Server.new(self, :port => port)
-
-          thread = Thread.new{ server.start }
-          thread[:adapter] = server
-          thread
+      def self.startup(host, port)
+        ::Ebb.log = StringIO.new
+        Thread.new do
+          ::Ebb.start_server(self, :port => port)
         end
       end
-    end
-  end
-
-  class Response
-    def finish(&block)
-      @block = block
 
-      if [201, 204, 304].include?(status.to_i)
-        header.delete "Content-Type"
-        [status.to_i, header.to_hash, '']
-      else
-        [status.to_i, header.to_hash, [body].flatten.join]
+      def self.shutdown
+        ::Ebb.stop_server
       end
     end
   end

data/lib/ramaze/adapter/fake.rb

@@ -0,0 +1,12 @@
+module Ramaze
+  module Adapter
+    class Fake < Base
+      def self.startup(host = nil, port = nil)
+        Thread.new{ loop{ sleep(1) } }
+      end
+
+      def self.shutdown
+      end
+    end
+  end
+end

data/lib/ramaze/adapter/fcgi.rb

@@ -7,17 +7,11 @@ module Ramaze
   module Adapter
     # Our Fcgi adapter acts as wrapper for the Rack::Handler::FastCGI.
     class Fcgi < Base
-      class << self
-
-        # start FastCGI in a new thread, host and port parameter are only taken
-        # to make it compatible with other adapters but have no influence and
-        # can be omitted
-        def run_server host = nil, ports = nil
-          Thread.new do
-            Thread.current[:task] = :cgi
-            Rack::Handler::FastCGI.run(self)
-          end
-        end
+      # start FastCGI in a new thread, host and port parameter are only taken
+      # to make it compatible with other adapters but have no influence and
+      # can be omitted
+      def self.startup(host = nil, port = nil)
+        Thread.new{ Rack::Handler::FastCGI.run(self) }
       end
     end
   end

data/lib/ramaze/adapter/lsws.rb

@@ -7,16 +7,12 @@ module Ramaze
   module Adapter
     # Our Lsws adapter acts as wrapper for the Rack::Handler::LSWS.
     class Lsws < Base
-      class << self
 
-        # start Lsws in a new thread, host and port parameter are only taken
-        # to make it compatible with other adapters but have no influence and
-        # can be omitted
-        def run_server host = nil, ports = nil
-          Thread.new do
-            Rack::Handler::LSWS.run(self)
-          end
-        end
+      # start Lsws in a new thread, host and port parameter are only taken
+      # to make it compatible with other adapters but have no influence and
+      # can be omitted
+      def self.startup(host = nil, port = nil)
+        Thread.new{ Rack::Handler::LSWS.run(self) }
       end
     end
   end

data/lib/ramaze/adapter/mongrel.rb

@@ -9,16 +9,12 @@ module Ramaze
 
     # Our Mongrel adapter acts as wrapper for the Rack::Handler::Mongrel.
     class Mongrel < Base
-      class << self
 
-        # start server on given host and port.
-        def run_server host, port
-          server = ::Mongrel::HttpServer.new(host, port)
-          server.register('/', ::Rack::Handler::Mongrel.new(self))
-          thread = server.run
-          thread[:adapter] = server
-          thread
-        end
+      # start server on given host and port.
+      def self.startup(host, port)
+        @server = ::Mongrel::HttpServer.new(host, port)
+        @server.register('/', ::Rack::Handler::Mongrel.new(self))
+        @server.run
       end
     end
   end

data/lib/ramaze/adapter/scgi.rb

@@ -7,14 +7,10 @@ module Ramaze
   module Adapter
     # Our Scgi adapter acts as wrapper for the Rack::Handler::SCGI.
     class Scgi < Base
-      class << self
-
-        # start SCGI in a new thread
-        def run_server host, port
-          Thread.new do
-            Thread.current[:task] = :cgi
-            Rack::Handler::SCGI.run(self, :Host=>host, :Port=>port)
-          end
+      # start SCGI in a new thread
+      def self.startup(host, port)
+        Thread.new do
+          Rack::Handler::SCGI.run(self, :Host => host, :Port => port)
         end
       end
     end

data/lib/ramaze/adapter/thin.rb

@@ -4,18 +4,13 @@ require 'rack/handler/thin'
 module Ramaze
   module Adapter
     class Thin < Base
-      class << self
+      # start server on given host and port.
+      def self.startup(host, port)
+        @server = ::Thin::Server.new(host, port, self)
+        ::Thin::Logging.silent = true
+        @server.timeout = 3
 
-        # start server on given host and port.
-        def run_server host, port
-          server = ::Thin::Server.new(host, port, self)
-          ::Thin::Logging.silent = true
-          server.timeout = 3
-
-          thread = Thread.new{ server.start }
-          thread[:adapter] = server
-          thread
-        end
+        Thread.new{ @server.start }
       end
     end
   end

data/lib/ramaze/adapter/webrick.rb

@@ -8,28 +8,19 @@ module Ramaze
   module Adapter
     # Our WEBrick adapter acts as wrapper for the Rack::Handler::WEBrick.
     class WEBrick < Base
-      class << self
-
-        # start server on given host and port, see below for possible options.
-        def run_server host, port, options = {}
-          options = {
-            :Port        => port,
-            :BindAddress => host,
-            :Logger      => Log,
-            :AccessLog   => [
-              [Log, ::WEBrick::AccessLog::COMMON_LOG_FORMAT],
-              [Log, ::WEBrick::AccessLog::REFERER_LOG_FORMAT]
-            ]
-          }.merge(options)
-
-
-          server = ::WEBrick::HTTPServer.new(options)
-          server.mount("/", ::Rack::Handler::WEBrick, self)
-          thread = Thread.new(server) do |adapter|
-            Thread.current[:adapter] = adapter
-            adapter.start
-          end
-        end
+      OPTIONS = {
+        :Logger      => Log,
+        :AccessLog   => [
+          [Log, ::WEBrick::AccessLog::COMMON_LOG_FORMAT],
+          [Log, ::WEBrick::AccessLog::REFERER_LOG_FORMAT]
+        ]
+      }
+
+      def self.startup(host, port)
+        options = OPTIONS.merge(:BindAddress => host, :Port => port)
+        @server = ::WEBrick::HTTPServer.new(options)
+        @server.mount('/', ::Rack::Handler::WEBrick, self)
+        Thread.new{ @server.start }
       end
     end
   end

data/lib/ramaze/cache.rb

@@ -38,12 +38,13 @@ module Ramaze
 
       def add *keys
         keys.each{|key|
-          klass = Global.cache_alternative.fetch(key, self)
+          klass = Global.cache_alternative.fetch(key, Global.cache)
           add_on(key, klass)
         }
         Log.dev("Added caches for: #{keys.join(', ')}")
       end
 
+      # Define a new cache available by Cache::key
       def add_on(key, cache_class)
         CACHES[key] = new(cache_class)
         CACHES[key].instance_variable_set("@cache_name", key)
@@ -59,31 +60,56 @@ module Ramaze
       @cache = cache.new
     end
 
-    # Get key.
+    # Gets the value for the given key, or +nil+ if not found.
     def [](key)
-      @cache["#{@cache_name}:#{key}"]
+      fetch(key)
     end
 
-    # Set key to value.
+    # Sets _key_ to _value_ with an infinite time to live.
     def []=(key, value)
-      @cache["#{@cache_name}:#{key}"] = value
+      store(key, value)
     end
 
-    # deletes the keys of each argument passed from Cache instance.
+    # Empties this cache.
+    def clear
+      @cache.clear
+    end
+
+    # Deletes each passed key from this cache.
     def delete(*args)
       args.each do |arg|
         @cache.delete("#{@cache_name}:#{arg}")
       end
     end
 
-    # Empty this cache
-    def clear
-      @cache.clear
+    # Gets the value of the given key, or _default_ if not found.
+    def fetch(key, default = nil)
+      return default unless entry = @cache["#{@cache_name}:#{key}"]
+      return entry[:value] if entry[:expires].nil? || entry[:expires] > Time.now
+      @cache.delete("#{@cache_name}:#{key}")
+      default
+    end
+
+    alias get fetch
+
+    # Sets key to value. Supports the following options:
+    #   [+:ttl+] time to live in seconds
+    def store(key, value, opts = {})
+      opts = {:ttl => opts} if opts.is_a?(Integer)
+      @cache["#{@cache_name}:#{key}"] = {
+        :expires => opts[:ttl] ? Time.now + opts[:ttl].to_i : nil,
+        :value   => value
+      }
+      value
     end
 
+    alias set store
+
     # Answers with value for each key.
     def values_at(*keys)
-      @cache.values_at(*keys.map {|key| "#{@cache_name}:#{key}" })
+      values = []
+      keys.each {|key| values << fetch(key) }
+      values
     end
   end
 end

data/lib/ramaze/cache/memcached.rb

@@ -14,9 +14,9 @@ module Ramaze
     #
     # For your own usage you should use another namespace.
 
-    def initialize(host = 'localhost', port = '11211', namespace = SEEED)
+    def initialize(host = 'localhost', port = '11211', namespace = Global.runner)
       namespace = Digest::SHA1.hexdigest(namespace)[0..16]
-      @cache = MemCache.new("#{host}:#{port}", :namespace => namespace, :multithread => true)
+      @cache = MemCache.new(["#{host}:#{port}"], :namespace => namespace, :multithread => true)
     end
 
     # please read the documentation of memcache-client for further methods.
@@ -63,6 +63,7 @@ module Ramaze
       get_multi(*keys).values_at(*keys)
     end
 
+    # Flush everything, dangerous!
     def clear
       @cache.flush_all
     end

data/lib/ramaze/contrib.rb

@@ -12,7 +12,7 @@ module Ramaze
   #   Ramaze.contrib :gzip_filter
 
   def self.contrib(*args)
-    Contrib.load *args
+    Contrib.load(*args)
   end
 
   # A module used for loading contrib modules.

data/lib/ramaze/contrib/email.rb

@@ -77,7 +77,7 @@ Message-Id: #{id}
         end
       rescue => e
         Log.error "Failed to send e-mail to #{recipient}"
-        Log.error e
+        Log.error [ e.class.to_s, e.message, *e.backtrace ].join( "\t\n" )
       end
     end
   end

data/lib/ramaze/contrib/file_cache.rb

@@ -47,7 +47,7 @@ module Ramaze::FileCache
   def self.delete *keys
     keys.map do |key|
       dirname = File.join Root, key
-      Fu.rm_rf dirname rescue next 
+      Fu.rm_rf dirname rescue next
     end
   end
 

data/lib/ramaze/contrib/gems.rb

@@ -0,0 +1,79 @@
+module Ramaze
+  module Gems
+    @gems = []
+
+    class << self
+      def gem(name, version = nil, options = {})
+        case version
+        when String
+          options[:version] = version
+        when Hash
+          options.merge!(version)
+        end
+
+        @gems << GemStone.new(name, options)
+      end
+
+      def options opts = {}
+        @options ||= { :docs => true }
+        @options.merge! opts unless opts.empty?
+        @options
+      end
+
+      def setup opts = {}
+        options(opts)
+        @gems.each{|gem| gem.setup }
+      end
+    end
+
+    class GemStone
+      attr_reader :name, :options
+
+      def initialize(name, options = {})
+        @name, @options = name, options
+      end
+
+      def setup(ran = false)
+        # rubygems resets the path after each successful install
+        Gem.use_paths Gems.options[:install_dir] if Gems.options[:install_dir]
+
+        Gem.activate(name, *[@options[:version]].compact)
+        require options[:lib] || name
+      rescue LoadError => error
+        puts error
+        return if ran
+        puts "attempting install"
+        install
+        setup(ran = true)
+      end
+
+      def install
+        require 'rubygems/gem_runner'
+        version, source = options.values_at(:version, :source)
+
+        cmd = %w[install] << name
+        cmd << "--no-rdoc" << "--no-ri" unless Gems.options[:docs]
+        cmd << "--install-dir" << Gems.options[:install_dir] if Gems.options[:install_dir]
+        cmd << "--version" << version if version
+        cmd << "--source" << source if source
+
+        puts cmd * ' '
+        Gem::GemRunner.new.run(cmd)
+      rescue Gem::SystemExitException => e
+        raise unless e.exit_code == 0
+      end
+    end
+  end
+end
+
+__END__
+Usage example:
+
+module Ramaze::Gems
+  gem 'haml'
+  gem 'sequel', '>=1.2.0'
+  gem 'hpricot', :source => 'http://code.whytheluckystiff.net'
+  gem 'aws-s3', :lib => 'aws/s3'
+
+  setup
+end

data/lib/ramaze/contrib/profiling.rb

@@ -3,7 +3,7 @@ require "ruby-prof"
 module Ramaze
   module Dispatcher
     class ActionProfiler < Action
-      def self.process(path)
+      def self.call(path)
         if RubyProf.running?
           super
         else