ramaze 0.0.6

data/lib/ramaze/adapter/webrick.rb

@@ -0,0 +1,161 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'cgi'
+require 'webrick'
+require 'benchmark'
+
+require 'ramaze/tool/tidy'
+
+# for OSX compatibility
+Socket.do_not_reverse_lookup = true
+
+module WEBrick
+  class HTTPRequest
+    attr_accessor :params
+
+    #  request_uri.path
+
+    def request_path
+      request_uri.path
+    end
+
+    #  peeraddr.last
+
+    def remote_addr
+      peeraddr.last
+    end
+
+    #  request_uri.path
+
+    def request_path
+      request_uri.path
+    end
+
+    # the headers of the current request.
+
+    def headers
+      return @headers if @headers
+      @headers = meta_vars.merge(header)
+      @headers.each do |key, value|
+        @headers.delete(key)
+        @headers[key.upcase] = value
+      end
+      @headers
+    end
+
+  end
+end
+
+module Ramaze::Adapter
+  class Webrick
+    class << self
+
+      # The method to start a new webrick-adapter on the specified
+      # host/ports, will return the first of the started adapters.
+      #
+      # sets up the default handler for the request/response cycle.
+
+      def start host, ports
+        handler = lambda do |request, response|
+          self.new.process(request, response)
+        end
+
+        ports.map{|port| run_server(host, port, handler) }.first
+      end
+
+      # run the actual server on host/port with the handler given.
+      # passes WEBrick::HTTPServlet the default options and starts
+      # it up in a new Thread, setting Thread.current[:adapter]
+
+      def run_server host, port, handler
+        options = {
+          :Port => port,
+          :BindAddress => host,
+          :Logger => Informer,
+          :AccessLog => [
+            [Informer, WEBrick::AccessLog::COMMON_LOG_FORMAT],
+            [Informer, WEBrick::AccessLog::REFERER_LOG_FORMAT]
+          ]
+        }
+
+        server = WEBrick::HTTPServer.new(options)
+        server.mount('/', WEBrick::HTTPServlet::ProcHandler.new(handler))
+
+        Thread.new do
+          Thread.current[:task] = :webrick
+          Thread.current[:adapter] = server
+          server.start
+        end
+      end
+
+      # doesn't do anything, for the time being.
+
+      def stop
+        debug "stopping WEBrick"
+      end
+    end
+
+    # process a request and give a response, based on the objects
+    # WEBrick gives it.
+    #
+    # if the Global.inform_tags include :benchmark it will run #bench_process,
+    # otherwise simply #respond.
+
+    def process request, response
+      if Global.inform_tags.include?(:benchmark)
+        bench_process(request, response)
+      else
+        respond(response, Dispatcher.handle(request, response))
+      end
+    end
+
+    # benchmark the current request/respond cycle and output the result
+    # via Inform#debug (so make sure you got :debug in your Global.inform_tags
+    #
+    # It works as a simple wrapper with no other impacts on the rest
+    # of the system.
+
+    def bench_process(request, response)
+      time = Benchmark.measure do
+        response = respond(response, Dispatcher.handle(request, response))
+      end
+      debug "#{request} took #{time.real}s"
+      response
+    end
+
+    # simply respond to a given request, #set_head and #set_out in the process
+    # as well as setting the response-status (which is, in case it is not
+    # given, 500, if nothing goes wrong it should be 200 or 302)
+
+    def respond orig_response, response
+      @response = orig_response
+      if response
+        set_head(response)
+        set_out(response)
+        @response.status = response.code || STATUS_CODE[:internal_server_error]
+      end
+      @response
+    end
+
+    # map the respond.head[key] to @response[key]
+
+    def set_head(response)
+      response.head.each do |key, val|
+        @response[key] = val
+      end
+    end
+
+    # set the body... in case you have Global.tidy = true it will run it
+    # through Tool::Tidy.tidy first (if your content-type is text/html)
+
+    def set_out response
+      @response.body =
+        if Global.tidy and response.content_type == 'text/html'
+          Tool::Tidy.tidy(response.out)
+        else
+          response.out
+        end
+    end
+  end
+end

data/lib/ramaze/cache.rb

@@ -0,0 +1,11 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  autoload :MemoryCache, "ramaze/cache/memory.rb"
+  autoload :YAMLStoreCache, "ramaze/cache/yaml_store.rb"
+  autoload :MemcachedCache, "ramaze/cache/memcached.rb"
+
+  Cache = nil
+  SessionCache = nil
+end

data/lib/ramaze/cache/memcached.rb

@@ -0,0 +1,52 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+require 'memcache'
+
+module Ramaze
+  class MemcachedCache
+    def initialize(host = 'localhost', port = '11211', namespace = 'ramaze')
+      @cache = MemCache.new("#{host}:#{port}", :namespace => namespace)
+    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)
+    end
+
+    # out of some reason MemCache sometimes doesn't respond to
+    # get_multi, have to investigate this further.
+    #
+    # for now, i'll just use the dumbed down version and ask it
+    # whether it implements this functionality or not.
+
+    def get_multi(*keys)
+      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
+  end
+end

data/lib/ramaze/cache/memory.rb

@@ -0,0 +1,6 @@
+#          Copyright (c) 2006 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,37 @@
+#          Copyright (c) 2006 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
+  class YAMLStoreCache
+
+    # create a new YAML::Store with the given file (which will be created if it
+    # is not already there).
+
+    def initialize(file = 'cache.yaml')
+      @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
+
+    # just a helper to use transactions.
+
+    def transaction(&block)
+      @cache.transaction(&block)
+    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/controller.rb

@@ -0,0 +1,10 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'ramaze/helper'
+
+module Ramaze
+  module Controller
+    include Ramaze::Helper
+  end
+end

data/lib/ramaze/dispatcher.rb

@@ -0,0 +1,315 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'timeout'
+
+module Ramaze
+
+  # The Dispatcher is the very heart of Ramaze itself.
+  #
+  # It will take requests and guide the request through all parts of the
+  # framework and your application.
+  #
+  # It is built in a way that lets you easily replace it with something you
+  # like better, since i'm very fond of the current implementation you can't
+  # find any examples of how this is done exactly yet.
+
+  module Dispatcher
+    class << self
+      include Trinity
+
+      # handle a request/response pair as given by the adapter.
+      # has to answer with a response.
+      #
+      # It is built so it will catch _all_ errors and exceptions
+      # thrown during processing of the request and #handle_error if
+      # a problem occurs.
+
+      def handle orig_request, orig_response
+        @orig_request, @orig_response = orig_request, orig_response
+        respond(orig_response, orig_request)
+      rescue Object => exception
+        error(exception)
+        handle_error(exception)
+      end
+
+      # The handle_error method takes an exception and decides based on that
+      # how it is going to respond in case of an error.
+      #
+      # In future this will become more and more configurable, right now
+      # you can provide your own error-method and error.xhtml inside either
+      # your trait[:template_root] or trait[:public].
+      #
+      # As more and more error-classes are being added to Ramaze you will get
+      # the ability to define your own response-pages and/or behaviour like
+      # automatic redirects.
+      #
+      # This feature is only available if your Global.error is true, which is
+      # the default.
+      #
+      # Yes, again, webrick _has_ to be really obscure, I searched for half an hour
+      # and still have not the faintest idea how request_path is related to
+      # request_uri...
+      # anyway, the solution might be simple?
+
+      def handle_error exception
+        meth_debug :handle_error, exception
+        Thread.current[:exception] = exception
+
+        case exception
+        when nil #Error::NoAction, Error::NoController
+          build_response(exception.message, STATUS_CODE[:not_found])
+        else
+          if Global.error_page
+            req = Thread.current[:request]
+
+            unless ((req.request_uri.path = '/error') rescue false)
+              req.request.params['REQUEST_PATH'] = '/error'
+            end
+
+            fill_out
+          else
+            build_response(exception.message, STATUS_CODE[:internal_server_error])
+          end
+        end
+      end
+
+      # setup the #setup_environment (Trinity) and start #fill_out
+
+      def respond orig_response, orig_request
+        setup_environment orig_response, orig_request
+        fill_out
+      end
+
+      #
+
+      def build_response out = '', code = STATUS_CODE[:internal_server_error], head = {}
+        default_head = {
+          'Content-Type' => 'text/plain',
+        }
+
+        if Global.cookies
+          default_head['Set-Cookie'] = session.export
+        else
+          head.delete('Set-Cookie')
+        end
+
+        head = default_head.merge(head)
+
+        Response.new(out, code, head)
+      end
+
+
+      # Obtain the path requested from the request and search for a static
+      # file matching the request, #respond_file is called if it finds one,
+      # otherwise the path is given on to #respond_action.
+      # Answers with a response
+
+      def fill_out
+        path = request.request_path.squeeze('/')
+        info "Request from #{request.remote_addr}: #{path}"
+
+        the_paths = $:.map{|way| (way/'public'/path) }
+        if file = the_paths.find{|way| File.exist?(way) and File.file?(way)}
+          respond_file file
+        else
+          respond_action path
+        end
+        response
+      end
+
+      # takes a file and sets the response.out to the contents of the file
+      # If you are running mongrel as your adapter it will take advantage of
+      # mongrels #send_file
+
+      def respond_file file
+        debug "Responding with static file: #{file}"
+
+        response.head['Content-Type'] = ''
+        if @orig_response.respond_to?(:send_file)
+          @orig_response.send_file(file)
+        else
+          response.out = File.read(file)
+        end
+      end
+
+      # Takes the path, figures out the controller by asking #resolve_controller
+      # for the controller, action and params for the path.
+      #
+      # Sets the cookies in the response.head if Global.cookies is set
+      #
+      # finally it runs #handle_controller
+
+      def respond_action path
+        debug "Responding with action: #{path}"
+
+        controller, action, params = resolve_controller(path)
+        catch :respond do
+          response.out = handle_controller(controller, action, params)
+        end
+      end
+
+      # find out which controller should be used based on the path.
+      # it will answer [controller, action, params] or raise an
+      #
+      #   Ramaze::Error::NoController # if no controller is found
+      #   Ramaze::Error::NoAction     # if no action but a controller is found
+      #
+      # It actually uses #resolve_action on almost every combination of
+      # so-called paractions (yet unsplit but possible combination of action
+      # and parameters for the action)
+      #
+      # If your templating is action-less, which means it does not depend on
+      # methods on the controller, but rather on templates or just dynamically
+      # calculated stuff you can set trait[:actionless] for your templating.
+      #
+      # Please see the documentation for Ramaze::Template::Amrita2 for an more
+      # specific example of how it is used in practice.
+      #
+      # Further it uses the Global.mapping to look up the controller to be used.
+      #
+      # Also, the action '/' will be expanded to 'index'
+      #
+      # Parameters are CGI.unescaped
+
+      def resolve_controller path
+        meth_debug :resolve_controller, path
+        track = path.split('/')
+        controller = false
+        action = false
+        tracks = []
+
+        track.unshift '/'
+
+        track.each do |atom|
+          tracks << (tracks.last.to_s / atom)
+        end
+
+        until controller and action or tracks.empty?
+          current = Regexp.escape(tracks.pop.to_s)
+          paraction = path.gsub(/^#{current}/, '').split('/').map{|e| CGI.unescape(e)}
+          paraction.delete('')
+          if controller = Ramaze::Global.mapping[current]
+            if controller.ancestral_trait[:actionless] or paraction == ['error']
+
+              action = paraction.shift
+              params = paraction
+              action = 'index' if action == nil
+            else
+              action, params = resolve_action controller, paraction
+            end
+          end
+        end
+
+        raise Ramaze::Error::NoController, "No Controller found for #{path}" unless controller
+        raise Ramaze::Error::NoAction, "No Action found for #{path}" unless action
+
+        return controller, action, params
+      end
+
+      # Resolve the method to be called and the number of parameters
+      # it will receive for a specific class (the controller) given the
+      # paraction (like 'foo/bar' => controller.call('foo', 'bar'))
+      # in case arity is 1 and a public instance-method named foo is defined.
+      #
+      # TODO:
+      # - find a solution for def x(a = :a) which has arity -1
+      #   identical to def x(*a) for some odd reason
+
+      def resolve_action controller, paraction
+        meth_debug :resolve_action, controller, paraction
+
+        meths =
+          (controller.ancestors - [Kernel, Object]).inject([]) do |sum, klass|
+            sum | (klass.is_a?(Module) ? klass.instance_methods(false) : sum)
+          end
+
+        track = paraction.dup
+        tracks = []
+        action = false
+
+        track.each do |atom|
+          atom = [tracks.last.to_s, atom]
+          atom.delete('')
+          tracks << atom.join('__')
+        end
+
+        tracks.unshift 'index'
+
+        until action or tracks.empty?
+          current = tracks.pop
+          if meths.include?(current)
+            arity = controller.instance_method(current).arity
+            params = (paraction - current.split('__'))
+
+            if params.size == arity
+              return current, params
+            elsif arity < 0 and arity + params.size >= 0
+              return current, params
+            elsif arity == -1
+              return current, params
+            end
+          end
+        end
+      end
+
+      # Depending on Global.cache_all and Global.cache_actions it will
+      # call either #handle_uncached_controller or #handle_cached_controller
+      # takes the controller, action and params and just passes them on.
+
+      def handle_controller controller, action, params
+        if Global.cache_all or Global.cache_actions[controller].include?(action.to_s)
+          handle_cached_controller(controller, action, *params)
+        else
+          handle_uncached_controller(controller, action, *params)
+        end
+      end
+
+      # Call the class-method handle_request with action and *params, all
+      # the controller has to do is to respond with a string.
+
+      def handle_uncached_controller controller, action, *params
+        controller.handle_request(action, *params)
+      end
+
+      # Call the class-method handle_request with action and *params, all
+      # the controller has to do is to respond with a string.
+      #
+      # To add a method for caching you can either use the CacheHelper
+      # or directly
+      #   Global.cache_actions[self] << 'index'
+      #
+      # Caching is done for [action, params] pairs per controller.
+
+      def handle_cached_controller controller, action, *params
+        Global.cached_actions ||= Global.cache.new
+
+        key = [action, params].inspect
+
+        Global.cached_actions[controller] ||= {key => nil}
+
+        if out = Global.cached_actions[controller][key]
+          debug "Using Cached version for #{key.inspect}"
+          return out
+        end
+
+        debug "Compiling Action: #{action} #{params.join(', ')}"
+        Global.cached_actions[controller][key] =
+          handle_uncached_controller(controller, action, *params)
+      end
+
+      # Setup the Trinity (Request, Response, Session) and store them as
+      # thread-variables in Thread.current
+      #   Thread.current[:request]  == Request.current
+      #   Thread.current[:response] == Response.current
+      #   Thread.current[:session]  == Session.current
+
+      def setup_environment orig_response, orig_request
+        this = Thread.current
+        this[:request]  = Request.new(orig_request)
+        this[:session]  = Session.new(request)
+        this[:response] = build_response('', STATUS_CODE[:ok], 'Content-Type' => 'text/html')
+      end
+    end
+  end
+end