Pistos-ramaze 2008.09

data/lib/ramaze/adapter/evented_mongrel.rb

@@ -0,0 +1,7 @@
+#          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.debug "Using Evented Mongrel"
+
+require 'swiftcore/evented_mongrel'
+require 'ramaze/adapter/mongrel'

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

@@ -0,0 +1,18 @@
+#          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
+  Global.test_connections = false
+
+  module Adapter
+    # Our Fcgi adapter acts as wrapper for the Rack::Handler::FastCGI.
+    class Fcgi < Base
+      # 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
+end

data/lib/ramaze/adapter/lsws.rb

@@ -0,0 +1,19 @@
+#          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
+  Global.test_connections = false
+
+  module Adapter
+    # Our Lsws adapter acts as wrapper for the Rack::Handler::LSWS.
+    class Lsws < Base
+
+      # 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
+end

data/lib/ramaze/adapter/mongrel.rb

@@ -0,0 +1,21 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'mongrel'
+require 'rack/handler/mongrel'
+
+module Ramaze
+  module Adapter
+
+    # Our Mongrel adapter acts as wrapper for the Rack::Handler::Mongrel.
+    class Mongrel < Base
+
+      # 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
+end

data/lib/ramaze/adapter/scgi.rb

@@ -0,0 +1,18 @@
+#          Copyright (c) 2008 Jeremy Evans  code@jeremyevans.net
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'rack/handler/scgi'
+
+module Ramaze
+  module Adapter
+    # Our Scgi adapter acts as wrapper for the Rack::Handler::SCGI.
+    class Scgi < Base
+      # 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
+  end
+end

data/lib/ramaze/adapter/swiftiplied_mongrel.rb

@@ -0,0 +1,7 @@
+#          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.debug "Using Swiftiplied Mongrel"
+
+require 'swiftcore/swiftiplied_mongrel'
+require 'ramaze/adapter/mongrel'

data/lib/ramaze/adapter/thin.rb

@@ -0,0 +1,17 @@
+require 'thin'
+require 'rack/handler/thin'
+
+module Ramaze
+  module Adapter
+    class Thin < Base
+      # 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
+
+        Thread.new{ @server.start }
+      end
+    end
+  end
+end

data/lib/ramaze/adapter/webrick.rb

@@ -0,0 +1,43 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'webrick'
+require 'rack/handler/webrick'
+
+module Ramaze
+  module Adapter
+    # Our WEBrick adapter acts as wrapper for the Rack::Handler::WEBrick.
+    class WEBrick < Base
+      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
+end
+
+# Extending on WEBrick module
+module WEBrick
+
+  # Extending on HTTPServlet
+  module HTTPServlet
+
+    # Extending on ProcHandler
+    #
+    # We alias PUT to GET and DELETE to GET so WEBrick handles them as well.
+    class ProcHandler
+      alias do_PUT do_GET
+      alias do_DELETE do_GET
+    end
+  end
+end

data/lib/ramaze/adapter.rb

@@ -0,0 +1,97 @@
+#          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/trinity'
+require 'ramaze/tool/record'
+require 'ramaze/adapter/base'
+require 'ramaze/adapter/fake'
+
+# for OSX compatibility
+Socket.do_not_reverse_lookup = true
+
+module Ramaze
+
+  # This module holds all classes and methods related to the adapters like
+  # webrick or mongrel.
+  # It's responsible for starting and stopping them.
+
+  module Adapter
+    class << self
+
+      # Is called by Ramaze.startup and will first call start_adapter and wait
+      # up to 3 seconds for an adapter to appear.
+      # It will then wait for the adapters to finish If Global.run_loose is
+      # set or otherwise pass you on control which is useful for testing or IRB
+      # sessions.
+
+      def startup options = {}
+        start_adapter
+
+        Timeout.timeout(3) do
+          sleep 0.01 until Global.server
+        end
+
+        Global.server.join unless Global.run_loose
+
+      rescue SystemExit
+        Ramaze.shutdown
+      rescue Object => ex
+        Log.error(ex)
+        Ramaze.shutdown
+      end
+
+      # Takes Global.adapter and starts if test_connections is positive that a
+      # connection can be made to the specified host and port.
+      # If you set Global.adapter to false it won't start any but deploy a
+      # dummy which is useful for testing purposes where you just send fake
+      # requests to Dispatcher.
+
+      def start_adapter
+        if adapter = Global.adapter
+          host, port = Global.host, Global.port
+
+          if Global.test_connections
+            test_connection(host, port)
+            Log.info("Ramaze is ready to run on: #{host}:#{port} using #{Global.adapter}")
+          end
+
+          adapter.start(host, port)
+        else
+          Fake.start
+          Log.warn("Seems like Global.adapter is turned off", "Continue without adapter.")
+        end
+      rescue LoadError => ex
+        Log.error(ex)
+        Log.warn("Continue without adapter.")
+      end
+
+      # Calls ::shutdown on all running adapters and waits up to 1 second for
+      # them to finish, then goes on to kill them and exit still.
+
+      def shutdown
+        Timeout.timeout(3) do
+          if Global.server.respond_to?(:shutdown)
+            Global.server.shutdown
+          end
+        end
+      rescue Timeout::Error
+        Global.server.kill!
+      end
+
+      # Opens a TCPServer temporarily and returns true if a connection is
+      # possible and false if none can be made
+
+      def test_connection(host, port)
+        Timeout.timeout(1) do
+          testsock = TCPServer.new(host, port)
+          testsock.close
+          true
+        end
+      rescue => ex
+        Log.error(ex)
+        Log.error("Cannot open connection on #{host}:#{port}")
+        Ramaze.shutdown
+      end
+    end
+  end
+end

data/lib/ramaze/cache/memcached.rb

@@ -0,0 +1,69 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+require 'memcache'
+
+module Ramaze
+
+  # Cache based on the memcache library which utilizes the memcache-daemon to
+  # store key/value pairs in namespaces.
+
+  class MemcachedCache
+
+    # Create a new MemcachedCache with host, port and a namespace that defaults
+    # to 'ramaze'
+    #
+    # For your own usage you should use another namespace.
+
+    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)
+    end
+
+    # please read the documentation of memcache-client for further methods.
+    # also, it is highly recommended to install memcache-client_extensions
+    # for a bit of speedup and more functionality
+    # Some examples:
+    #
+    # [key]                       #=> get a key
+    # [key] = value               #=> set a key
+    # delete(key)                 #=> delete key
+    # set_many :x => :y, :n => :m #=> set many key/value pairs
+    # get_hash :x, :y             #=> return a hash with key/value pairs
+    # stats                       #=> get some statistics about usage
+    # namespace                   #=> get the current namespace
+    # namespace = 'ramaze'        #=> set a different namespace ('ramaze' is default)
+    # flush_all                   #=> flush the whole cache (deleting all)
+    # compression                 #=> see if compression is true/false
+    # compression = false         #=> turn off compression (it's by default true)
+
+    def method_missing(*args, &block)
+      @cache.__send__(*args, &block)
+    rescue MemCache::MemCacheError => e
+      Log.error e.to_s
+      nil
+    end
+
+    # Fetch for multiple keys at once.
+
+    def get_multi(*keys)
+      # MemCache only responds to get_multi if the memcache-client_extensions gem
+      # is installed, so we check first and resort to another approach if not.
+      if @cache.respond_to?(:get_multi)
+        @cache.get_multi(*keys)
+      else
+        @cache.get_hash(*keys)
+      end
+    end
+
+    # same as get_multi, but returns only the values (in order)
+
+    def values_at(*keys)
+      get_multi(*keys).values_at(*keys)
+    end
+
+    # Flush everything, dangerous!
+    def clear
+      @cache.flush_all
+    end
+  end
+end

data/lib/ramaze/cache/memory.rb

@@ -0,0 +1,6 @@
+#          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
+  MemoryCache = Hash
+end

data/lib/ramaze/cache/yaml_store.rb

@@ -0,0 +1,68 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+require 'yaml/store'
+
+module Ramaze
+
+  # Cache based on _whys YAML::Store, which uses PStore to serialize objects
+  # as YAML in a thread-safe manner.
+
+  class YAMLStoreCache
+
+    attr_accessor :file
+
+    # create a new YAML::Store with the given file (which will be created if it
+    # is not already there).
+
+    def initialize(file = 'cache.yaml')
+      @file = file
+      @cache = YAML::Store.new(file)
+    end
+
+    # return the values for given keys.
+
+    def values_at(*keys)
+      transaction do |y|
+        keys.map{|k| y[k]}
+      end
+    end
+
+    # Loads @file into memory via YAML::load_file
+
+    def underlying_yaml
+      YAML.load_file(@file)
+    end
+
+    # clears the YAML::Store based cache, by emptying the YAML file.
+
+    def clear
+      transaction do |y|
+        File.open(@file, 'w+'){|f| f.puts({}.to_yaml)}
+      end
+    end
+
+    # Deletes the key from YAML::Store based cache.
+
+    def delete(key)
+      transaction do |y|
+        y.delete(key)
+      end
+    end
+
+    # just a helper to use transactions.
+
+    def transaction(&block)
+      @cache.transaction do
+        yield(@cache)
+      end
+    end
+
+    # catch everything else and use a transaction to send it.
+
+    def method_missing(*args, &block)
+      transaction do |y|
+        y.send(*args, &block)
+      end
+    end
+  end
+end

data/lib/ramaze/cache.rb

@@ -0,0 +1,113 @@
+#          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/cache/memory'
+
+module Ramaze
+  autoload :YAMLStoreCache, "ramaze/cache/yaml_store.rb"
+  autoload :MemcachedCache, "ramaze/cache/memcached.rb"
+
+  # This is the wrapper of all caches, providing mechanism
+  # for switching caching from one adapter to another.
+
+  class Cache
+    include Enumerable
+
+    # Holds all the instances of Cache that are being added.
+    CACHES = {} unless defined?(CACHES)
+
+    attr_accessor :cache
+
+    class << self
+
+      # Initializes the Cache for the general caches Ramaze uses.
+      # Cache#startup is called by Ramaze#startup, when initializing the
+      # Ramaze.trait(:essentials).
+
+      def startup(options)
+        Cache.add :compiled, :actions, :patterns,
+                  :resolved, :shield, :action_methods
+      end
+
+      # This will define a method to access a new cache directly over
+      # singleton-methods on Cache.
+      #---
+      # The @cache_name is internally used for caches which do not save
+      # different caches in different namespaces, for example memcached.
+      #+++
+
+      def add *keys
+        keys.each{|key|
+          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)
+        eval("def self.%s; CACHES[%p]; end" % [key, key])
+      end
+
+    end
+
+    # Initializes the cache, defined by Global.cache
+    def initialize(cache = Global.cache)
+      @cache = cache.new
+    end
+
+    # Gets the value for the given key, or +nil+ if not found.
+    def [](key)
+      fetch(key)
+    end
+
+    # Sets _key_ to _value_ with an infinite time to live.
+    def []=(key, value)
+      store(key, value)
+    end
+
+    # 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
+
+    # 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)
+      values = []
+      keys.each {|key| values << fetch(key) }
+      values
+    end
+  end
+end

data/lib/ramaze/contrib/auto_params/get_args.rb

@@ -0,0 +1,58 @@
+# from merb/core_ext/get_args.rb
+begin
+  require 'parse_tree'
+  require 'ruby2ruby'
+
+  class ParseTreeArray < Array
+    def self.translate(*args)
+      self.new(ParseTree.translate(*args))
+    end
+
+    def deep_array_node(type = nil)
+      each do |node|
+        return ParseTreeArray.new(node) if node.is_a?(Array) && (!type || node[0] == type)
+        next unless node.is_a?(Array)
+        return ParseTreeArray.new(node).deep_array_node(type)
+      end
+      nil
+    end
+
+    def arg_nodes
+      self[1..-1].inject([]) do |sum,item|
+        sum << [item] unless item.is_a?(Array)
+        sum
+      end
+    end
+
+    def get_args
+      arg_node = deep_array_node(:args)
+      return nil unless arg_node
+      args = arg_node.arg_nodes
+      default_node = arg_node.deep_array_node(:block)
+      return args unless default_node
+      lasgns = default_node[1..-1]
+      lasgns.each do |asgn|
+        args.assoc(asgn[1]) << eval(RubyToRuby.new.process(asgn[2]))
+      end
+      args
+    end
+
+  end
+
+  module GetArgs
+    def get_args
+      klass, meth = self.to_s.split(/ /).to_a[1][0..-2].split("#")
+      klass = $` if klass =~ /\(/
+      ParseTreeArray.translate(Object.const_get(klass), meth).get_args
+    end
+  end
+
+  class UnboundMethod
+    include GetArgs
+  end
+
+  class Method
+    include GetArgs
+  end
+rescue LoadError
+end