ramaze 0.0.9 → 0.1.0

data/lib/ramaze/adapter.rb

@@ -4,14 +4,24 @@
 require 'rack'
 require 'benchmark'
 
+require 'ramaze/trinity'
+
 # for OSX compatibility
 Socket.do_not_reverse_lookup = true
 
+class Rack::Request
+  include Ramaze::Request
+end
+
+class Rack::Response
+  include Ramaze::Response
+end
+
 module Ramaze::Adapter
   class Base
     class << self
       def stop
-        Informer.debug "Stopping #{self.class}"
+        Inform.debug("Stopping #{self.class}")
       end
 
       def call(env)
@@ -20,32 +30,25 @@ module Ramaze::Adapter
     end
 
     def call(env)
-      if Ramaze::Global.inform_tags.include?(:benchmark)
+      if Ramaze::Global.benchmarking
         time = Benchmark.measure{ respond env }
-        info "request took #{time.real}s"
+        Inform.debug("request took #{time.real}s")
       else
         respond env
       end
 
-      @response = Thread.current[:response]
-
-      [@response.status, @response.header, self]
+      finish
     end
 
-    def respond env
-      Ramaze::Dispatcher.handle(::Rack::Request.new(env), ::Rack::Response.new)
-    end
+    def finish
+      response = Thread.current[:response]
 
-    def each
-      body = @response.body
+      response.finish
+    end
 
-      if body.respond_to?(:read)
-        until body.eof?
-          yield body.read(1024)
-        end
-      else
-        yield body
-      end
+    def respond env
+      request, response = Rack::Request.new(env), Rack::Response.new
+      Ramaze::Dispatcher.handle(request, response)
     end
   end
 end

data/lib/ramaze/adapter/mongrel.rb

@@ -5,9 +5,6 @@ require 'ramaze/adapter'
 
 require 'mongrel'
 
-# for OSX compatibility
-Socket.do_not_reverse_lookup = true
-
 module Ramaze::Adapter
   class Mongrel < Base
     class << self

data/lib/ramaze/adapter/webrick.rb

@@ -3,7 +3,7 @@
 
 require 'ramaze/adapter'
 
-require 'webrick'
+require 'rack/handler/webrick'
 
 module WEBrick
   module HTTPServlet
@@ -25,16 +25,16 @@ module Ramaze::Adapter
         options = {
           :Port => port,
           :BindAddress => host,
-          :Logger => Ramaze::Informer,
+          :Logger => Ramaze::Inform,
           :AccessLog => [
-            [Ramaze::Informer, WEBrick::AccessLog::COMMON_LOG_FORMAT],
-            [Ramaze::Informer, WEBrick::AccessLog::REFERER_LOG_FORMAT]
+            [Ramaze::Inform, WEBrick::AccessLog::COMMON_LOG_FORMAT],
+            [Ramaze::Inform, WEBrick::AccessLog::REFERER_LOG_FORMAT]
           ]
         }.merge(options)
 
         Thread.new do
-          Thread.current[:task] = :webrick
-          Rack::Handler::WEBrick.run(self, options)
+          Thread.current[:adapter] =
+            Rack::Handler::WEBrick.run(self, options)
         end
       end
     end

data/lib/ramaze/cache/memcached.rb

@@ -33,6 +33,9 @@ module Ramaze
 
     def method_missing(*args, &block)
       @cache.__send__(*args, &block)
+    rescue MemCache::MemCacheError => e
+      Ramaze::Inform.error e.to_s
+      nil
     end
 
     # out of some reason MemCache sometimes doesn't respond to

data/lib/ramaze/controller.rb

@@ -5,249 +5,292 @@ require 'ramaze/template'
 
 module Ramaze
 
+  class Action < Struct.new('Action', :method, :params, :template)
+    def to_s
+      %{#<Action method=#{method.inspect}, params=#{params.inspect} template=#{template.inspect}>}
+    end
+  end
+
   # The Controller is responsible for combining and rendering actions.
 
   class Controller
     include Ramaze::Helper
     extend Ramaze::Helper
 
-    helper :redirect, :link
+    helper :redirect, :link, :file
 
     trait :template_extensions => { }
 
     # Path to the ramaze-internal public directory for error-pages and the like.
     # It acts just as a shadow.
-    trait :public => ( ::Ramaze::BASEDIR / 'proto' / 'public' )
+    trait :ramaze_public => ( ::Ramaze::BASEDIR / 'proto' / 'public' )
+
+    # Whether or not to map this controller on startup automatically
+
+    trait :automap => true
+
+    # Place to map the Controller to, this is something like '/' or '/foo'
+
+    trait :map => nil
+
+    trait :exclude_action_modules => [Kernel, Object, PP::ObjectMixin]
+
+    trait :pattern_cache => Hash.new{|h,k| h[k] = Controller.pattern_for(k) }
+
+    trait :action_cache  => Global.cache.new
 
     class << self
       include Ramaze::Helper
       extend Ramaze::Helper
 
+      def inherited controller
+        controller.trait :actions_cached => Set.new
+        Global.controllers << controller
+      end
+
+      def validate_sanity
+        if path = trait[:public]
+          unless File.directory?(path)
+            Inform.warn("#{controller} uses templating in #{path}, which does not exist")
+          end
+        end
+      end
+
+      def mapping
+        global_mapping = Global.mapping.invert[self]
+        return global_mapping if global_mapping
+        if map = class_trait[:map]
+          map
+        elsif ancestral_trait[:automap]
+          name = self.to_s.gsub('Controller', '').split('::').last
+          %w[Main Base Index].include?(name) ? '/' : "/#{name.snake_case}"
+        end
+      end
+
+      def map(*syms)
+        syms.each do |sym|
+          Global.mapping[sym.to_s] = self
+        end
+      end
+
+      def current
+        Thread.current[:controller]
+      end
+
       def handle path
-        controller, action, params = *resolve_controller(path)
-        action, params = path.gsub(/^\//, '').split('/').join('__'), [] unless action
-        controller = self unless controller
-        controller.render action, *params
-      rescue Ramaze::Error::Template => ex
-        puts ex
-        ''
+        controller, action = *resolve(path)
+        controller.render(action)
       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'
+
+      # #ramaze - 9.5.2007
       #
-      # Parameters are CGI.unescaped
+      # manveru    | if no possible controller is found, it's a NoController error
+      # manveru    | that would be a 404 then
+      # Kashia     | aye
+      # manveru    | if some controller are found but no actions on them, it's NoAction Error for the first controller found, again, 404
+      # manveru    | everything further down is considered 500
 
-      def resolve_controller path
-        Informer.meth_debug :resolve_controller, path
-        track = path.split('/')
-        controller = false
-        action = false
-        tracks = []
+      def resolve(path)
+        #Inform.debug("resolve_controller('#{path}')")
+        mapping     = Global.mapping
+        controllers = Global.controllers
 
-        track.unshift '/'
+        raise_no_controller(path) if controllers.empty? or mapping.empty?
 
-        track.each do |atom|
-          tracks << (tracks.last.to_s / atom)
-        end
+        patterns = Controller.trait[:pattern_cache][path]
+        first_controller = nil
 
-        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] and controller.respond_to?(:render)
-            if paraction == ['error']
-
-              action = paraction.shift
-              params = paraction
-              action = 'index' if action == nil
-            else
-              action, params = resolve_action controller, paraction
-            end
+        patterns.each do |controller, method, params|
+          if controller = mapping[controller]
+            first_controller ||= controller
+
+            action = controller.resolve_action(method, *params)
+            template = action.template
+
+            action.method ||= File.basename(template, File.extname(template)) if template
+
+            return controller, action if action.method
           end
         end
 
-        return controller, action, params
+        raise_no_action(first_controller, path) if first_controller
+        raise_no_controller(path)
       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(path, *parameter)
+        path, parameter = path.to_s, parameter.map(&:to_s)
+        possible_path = trait["#{path}_template".to_sym]
+        template = resolve(possible_path).last.template if possible_path
 
-      def resolve_action controller, paraction
-        Informer.meth_debug :resolve_action, controller, paraction
+        method, params = resolve_method(path, *parameter)
 
-        meths =
-          (controller.ancestors - [Kernel, Object]).inject([]) do |sum, klass|
-            sum | (klass.is_a?(Module) ? klass.instance_methods(false) : sum)
-          end
+        if method or parameter.empty?
+          template ||= resolve_template(path)
+        end
+
+        Action.new(method, params, template)
+      end
+
+      def resolve_template(action)
+        action = action.to_s
+        action_converted = action.split('__').inject{|s,v| s/v}
+        actions = [action, action_converted].compact
 
-        track = paraction.dup
-        tracks = []
-        action = false
+        paths = template_paths.map{|pa| actions.map{|a| pa/a } }.flatten.uniq
+        glob = "{#{paths.join(',')}}.{#{extension_order.join(',')}}"
+
+        Dir[glob].first
+      end
+
+      def template_paths
+        klass_public = trait[:public]
+        ramaze_public = Controller.trait[:ramaze_public]
+
+        first_path =
+          if template_root = class_trait[:template_root]
+            template_root
+          else
+            Global.template_root / Global.mapping.invert[self]
+          end
+        [ first_path, klass_public, ramaze_public].compact
+      end
 
-        track.each do |atom|
-          atom = [tracks.last.to_s, atom]
-          atom.delete('')
-          tracks << atom.join('__')
+      def resolve_method(name, *params)
+        if method = action_methods.delete(name)
+          arity = instance_method(method).arity
+          if params.size == arity or arity < 0
+            return method, params
+          end
         end
+        return nil, []
+      end
+
+      def action_methods
+        exclude = Controller.trait[:exclude_action_modules]
+
+        ancs = (ancestors - exclude).select{|a| a.is_a?(Module)}
+        ancs.map{|a| a.instance_methods(false).map(&:to_s)}.flatten.uniq
+      end
+
+      def pattern_for(path)
+        atoms = path.split('/').grep(/\S/)
+        atoms.unshift('')
+        patterns, joiners = [], ['/']
+
+        atoms.size.times do |enum|
+          enum += 1
+          joiners << '__' if enum == 3
 
-        tracks.unshift 'index'
+          joiners.each do |joinus|
+            pattern = atoms.dup
 
-        until action or tracks.empty?
-          current = tracks.pop
-          if meths.include?(current) #or current = controller.ancestral_trait[:template_map][current]
-            arity = controller.instance_method(current).arity
-            params = (paraction - current.split('__'))
+            controller = pattern[0, enum].join(joinus)
+            controller.gsub!(/^__/, '/')
+            controller = "/" if controller == ""
 
-            if params.size == arity
-              return current, params
-            elsif arity < 0
-              return current, params
+            pattern = pattern[enum..-1]
+            args, temp = [], []
+
+            patterns << [controller, 'index', atoms[enum..-1]]
+
+            until pattern.empty?
+              args << pattern.shift
+              patterns << [controller, args.join( '__' ), pattern.dup]
             end
           end
         end
+
+        patterns.reverse!
       end
 
-      # The universal #render method that has to be provided by every
-      # prospective Controller, pass it your action and parameters.
-      #
-      # This is called upon by the Dispatcher, but you can use it in your
-      # Controller/View to get the contents of another action.
-      #
-      # It will set the instance-variable @action in the instance of itself
-      # to the value of the current action.
+      def extension_order
+        t_extensions = Controller.trait[:template_extensions]
+        engine = trait[:engine]
+        c_extensions = t_extensions.reject{|k,v| v != engine}.keys
+        all_extensions = t_extensions.keys
+        (c_extensions + all_extensions).uniq
+      end
 
-      def render action, *parameter
-        trait[:actions_cached] ||= Set.new
+      def render(action = {})
+        action = Action.fill(action) if action.is_a?(Hash)
+        Inform.debug("The Action: #{action}")
 
-        cache_indicators = [
-          Global.cache_all,
-          ancestral_trait[:cache_all],
-          ancestral_trait[:actions_cached].map{|k| k.to_s}.include?(action.to_s),
-        ]
+        action.method = action.method.to_s
+        action.params.compact!
 
-        if cache_indicators.any?
-          cached_render(action, *parameter)
+        if cached?(action)
+          cached_render(action)
         else
-          uncached_render(action, *parameter)
+          uncached_render(action)
         end
       end
 
-      def uncached_render action, *parameter
-        controller = self.new
-        controller.instance_variable_set('@action', action)
+      def cached?(action)
+        actions_cached = trait[:actions_cached]
+
+        [ Global.cache_all,
+          trait[:cache_all],
+          actions_cached.map{|k| k.to_s}.include?(action.method),
+        ].any?
+      end
 
-        file   = find_template(action)
-        engine = ancestral_trait[:engine] || engine_for(file)
+      def uncached_render(action)
+        controller = self.new
+        controller.instance_variable_set('@action', action.method)
+        Thread.current[:controller] = controller
 
         options = {
-          :file     => file,
-          :binding  => controller.send(:send, :binding),
-          :action => action,
-          :parameter => parameter,
+          :file       => action.template,
+          :binding    => controller.instance_eval{ binding },
+          :action     => action.method,
+          :parameter  => action.params,
         }
+
+        engine = select_engine(options[:file])
         engine.transform(controller, options)
       end
 
-      def cached_render action, *parameter
-        key = [action, parameter].inspect
-
-        trait[:action_cache] ||= Global.cache.new
+      def cached_render action
+        action_cache = Controller.trait[:action_cache]
 
-        if out = ancestral_trait[:action_cache][key]
-          Informer.debug "Using Cached version for #{key}"
+        if out = action_cache[action]
+          Inform.debug("Using Cached version for #{action}")
           return out
         end
 
-        Informer.debug "Compiling Action: #{action} #{parameter.join(', ')}"
-        ancestral_trait[:action_cache][key] = uncached_render(action, *parameter)
+        Inform.debug("Compiling Action: #{action}")
+        action_cache[action] = uncached_render(action)
       end
 
-      # This finds the template for the given action on the current controller
-      # there are some basic ways how you can provide an alternative path:
-      #
-      # Global.template_root = 'default/path'
-      #
-      # class FooController < Controller
-      #   trait :template_root => 'another/path'
-      #   trait :index_template => :foo
-      #
-      #   def index
-      #   end
-      # end
-      #
-      # One feature also used in the above example is the custom template for
-      # one action, in this case :index - now the template of :foo will be
-      # used instead.
-
-      def find_template action, klass = self
-        custom_template = ancestral_trait["#{action}_template".intern]
-        action = (custom_template ? custom_template : action).to_s
-        action_converted = action.split('__').inject {|s,v| "#{s}/#{v}"}
-
-        first_path =
-          if template_root = klass.ancestral_trait[:template_root]
-            template_root
-          else
-            Global.template_root / Global.mapping.invert[self]
-          end
-
-        extensions = [ancestral_trait[:template_extensions].values].flatten.uniq
+      def select_engine(file)
+        trait_engine = class_trait[:engine]
+        default = [trait_engine, Template::Ezamar].compact.first
+        return default unless file
 
-        paths = [ first_path, ancestral_trait[:public], ].
-                  map{|pa| [ pa / action, pa / action_converted ] }.
-                  flatten.map{|pa| File.expand_path(pa) }.join(',')
+        engines = Controller.trait[:template_extensions]
+        return default if engines.empty?
 
-        glob = "{#{paths}}.{#{extensions.join(',')}}"
-
-        possible = Dir[glob]
-        possible.first
-      end
-
-      # lookup the trait[:template_extensions] for the extname of the filename
-      # you pass.
-      #
-      # Answers with the engine that matches the extension, Template::Ezamar
-      # is used if none matches.
-
-      def engine_for file
-        file = file.to_s
-        extension = File.extname(file).gsub(/^\./, '')
-        engines = trait[:template_extensions]
-        engines.find{|k,v| v == extension or [v].flatten.include?(extension)}.first
-      rescue
-        Template::Ezamar
+        ext = File.extname(file).gsub(/^\./, '')
+        ext_engine = engines[ext]
+        return ext_engine ? ext_engine : default
       end
 
       # This method is called by templating-engines to register themselves with
       # a list of extensions that will be looked up on #render of an action.
 
       def register_engine engine, *extensions
-        trait[:template_extensions][engine] = [extensions].flatten.uniq
+        extensions.flatten.each do |ext|
+          trait[:template_extensions][ext] = engine
+        end
+      end
+
+      def raise_no_controller(path)
+        raise Ramaze::Error::NoController, "No Controller found for `#{path}'"
+      end
+
+      def raise_no_action(controller, path)
+        raise Ramaze::Error::NoAction, "No Action found for `#{path}' on #{controller}"
       end
     end
 
@@ -261,34 +304,35 @@ module Ramaze
 
     def error
       error = Thread.current[:exception]
-      backtrace = error.backtrace[0..20]
+      @backtrace = error.backtrace[0..20]
       title = error.message
 
-      colors = []
+      @colors = []
       min = 200
       max = 255
-      step = -((max - min) / backtrace.size).abs
+      step = -((max - min) / @backtrace.size).abs
       max.step(min, step) do |color|
-        colors << color
+        @colors << color
       end
 
-      backtrace.map! do |line|
+      backtrace_size = Ramaze::Global.backtrace_size
+
+      @backtrace.map! do |line|
         file, lineno, meth = *Ramaze.parse_backtrace(line)
-        backtrace_size = Ramaze::Global.inform_backtrace_size
         lines = Ramaze.caller_lines(file, lineno, backtrace_size)
 
         [ lines, lines.object_id.abs, file, lineno, meth ]
       end
 
-      response.status = 404
-
-      @backtrace = backtrace
-      @colors = colors
       @title = CGI.escapeHTML(title)
       require 'coderay'
       @coderay = true
+      title
     rescue LoadError => ex
       @coderay = false
+      title
+    rescue Object => ex
+      Inform.error(ex)
     end
 
     private