ramaze 0.1.0 → 0.1.1

data/lib/ramaze/controller/resolve.rb

@@ -0,0 +1,147 @@
+#          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
+  class Controller
+    class << self
+      # #ramaze - 9.5.2007
+      #
+      # 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(path)
+        #Inform.debug("resolve_controller('#{path}')")
+        mapping     = Global.mapping
+        controllers = Global.controllers
+
+        raise_no_controller(path) if controllers.empty? or mapping.empty?
+
+        patterns = Cache.patterns[path] ||= pattern_for(path)
+        first_controller = nil
+
+        patterns.each do |controller, method, params|
+          if controller = mapping[controller]
+            first_controller ||= controller
+
+            action = controller.resolve_action(method, *params)
+            template = action.template
+
+            valid_action = (action.method or (params.empty? && action.template))
+
+            return controller, action if valid_action
+          end
+        end
+
+        raise_no_action(first_controller, path) if first_controller
+        raise_no_controller(path)
+      end
+
+      def resolve_action(path, *parameter)
+        path, parameter = path.to_s, parameter.map(&:to_s)
+        if alternate_template = trait["#{path}_template"]
+          t_controller, t_path = *alternate_template
+          template = t_controller.resolve_template(t_path)
+        end
+
+        method, params = resolve_method(path, *parameter)
+
+        if method or parameter.empty?
+          template ||= resolve_template(path)
+        end
+
+        hash = {:method => method, :params => params, :template => template}
+        Action.fill(hash)
+      end
+
+      def resolve_template(action)
+        action = action.to_s
+        action_converted = action.split('__').inject{|s,v| s/v}
+        actions = [action, action_converted].compact
+
+        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
+        first_path =
+          if template_root = @template_root
+            template_root
+          else
+            Global.template_root / Global.mapping.invert[self]
+          end
+        [ first_path, public_root, Global.public_root ].compact
+      end
+
+      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)}
+        meths = ancs.map{|a| a.instance_methods(false).map(&:to_s)}.flatten.uniq
+        # fix for facets/more/paramix
+        meths - ancs.map(&:to_s)
+      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
+
+          joiners.each do |joinus|
+            pattern = atoms.dup
+
+            controller = pattern[0, enum].join(joinus)
+            controller.gsub!(/^__/, '/')
+            controller = "/" if controller == ""
+
+            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
+
+      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 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
+  end
+end

data/lib/ramaze/dispatcher.rb

@@ -3,6 +3,7 @@
 
 require 'timeout'
 
+require 'ramaze/error'
 require 'ramaze/adapter'
 require 'ramaze/tool/mime'
 
@@ -19,25 +20,37 @@ module Ramaze
     ]
 
     trait :handle_error => {
-        Exception                   => [500, '/error'],
-        Ramaze::Error::NoAction     => [404, '/error'],
-        Ramaze::Error::NoController => [404, '/error'],
+        Exception =>
+          [ STATUS_CODE["Internal Server Error"], '/error' ],
+        Ramaze::Error::NoAction =>
+          [ STATUS_CODE["Not Found"], '/error' ],
+        Ramaze::Error::NoController =>
+          [ STATUS_CODE["Not Found"], '/error' ],
       }
 
+    Cache.add :shield
+
+    trait :shielded => [ STATUS_CODE["Not Found"] ]
+
     class << self
       include Trinity
 
       def handle rack_request, rack_response
         setup_environment(rack_request, rack_response)
-        dispatch
-      rescue Object => error
-        Dispatcher::Error.process(error)
-      end
 
-      def dispatch
         path = request.path_info.squeeze('/')
         Inform.info("Request from #{request.remote_addr}: #{path}")
 
+        if Global.shield
+          shielded_dispatch(path)
+        else
+          dispatch(path)
+        end
+      rescue Object => error
+        Dispatcher::Error.process(error)
+      end
+
+      def dispatch(path)
         catch(:respond) do
           redirection = catch(:redirect) do
             found = filter(path)
@@ -53,7 +66,26 @@ module Ramaze
       def dispatch_to path
         raise "Redirect to #{path} from #{path}" if request.path_info == path
         request.path_info = path
-        dispatch
+
+        if Global.shield
+          shielded_dispatch(path)
+        else
+          dispatch(path)
+        end
+      end
+
+      def shielded_dispatch(path)
+        shield_cache = Cache.shield
+        handled = shield_cache[path]
+        return handled if handled
+
+        dispatched = dispatch(path)
+
+        unless trait[:shielded].include?(dispatched.status)
+          dispatched
+        else
+          shield_cache[path] = dispatched
+        end
       end
 
       def filter path

data/lib/ramaze/dispatcher/file.rb

@@ -7,7 +7,7 @@ module Ramaze
       class << self
         def process(path)
           return unless file = open_file(path)
-          Dispatcher.build_response(file, Ramaze::STATUS_CODE[:ok])
+          Dispatcher.build_response(file, Ramaze::STATUS_CODE['OK'])
         end
 
         def lookup_paths

data/lib/ramaze/global.rb

@@ -4,166 +4,81 @@
 require 'ostruct'
 require 'set'
 
+require 'ramaze/global/dsl'
+
 module Ramaze
-  class GlobalStruct < OpenStruct
-    # autoreload     - Interval for autoreloading changed source in seconds
-    # adapter        - Webserver-adapter ( :mongrel | :webrick )
-    # backtrace_size - size of backtrace to be logged (and shown on error-page).
-    # benchmarking   - enable timing of each request
-    # cache          - Cache to use   ( MemcachedCache | MemoryCache | YamlStoreCache )
-    # cache_all      - Naive caching for all responses ( true | false )
-    # cookies        -
-    # error_page     - Show default errorpage with inspection and backtrace ( true | false )
-    # host           - Host to respond to ( '0.0.0.0' )
-    # mapping        - Route to controller map ( {} )
-    # port           - First port of the port-range the adapters run on. ( 7000 )
-    # run_loose      - Don't wait for the servers to finish, useful for testing ( true | false )
-    # template_root  - Default directory for your templates.
-    #
-    # startup         - List of methods and lambdas that are executed on startup
-    # ramaze_startup  - Internal list of methods and lambdas that are executed on startup
-    #
-    # shutdown        - List of methods and lambdas that are executed on startup
-    # ramaze_shutdown - Internal list of methods and lambdas that are executed on shutdown
-
-    DEFAULT = {
-      :autoreload       => 5,
-      :adapter          => :webrick,
-      :backtrace_size   => 10,
-      :benchmarking     => false,
-      :cache            => MemoryCache,
-      :cache_all        => false,
-      :controllers      => Set.new,
-      :cookies          => true,
-      :error_page       => true,
-      :host             => '0.0.0.0',
-      :localize         => lambda{ Ramaze::Tool::Localize.trait },
-      :logger           => Ramaze::Informer.new($stdout),
-      :mapping          => {},
-      :port             => 7000,
-      :run_loose        => false,
-      :template_root    => 'template',
-      :tidy             => lambda{ Ramaze::Tool::Tidy.trait },
-      :test_connections => true,
-      :shutdown_trap    => 'SIGINT',
-
-      :startup => [
-        lambda{
-          Ramaze::Inform = Global.logger unless defined?(Inform)
-          Inform.info("Starting up Ramaze (Version #{VERSION})")
-        }
-      ],
-      :ramaze_startup => [
-        :setup_controllers, :init_autoreload, :init_adapter
-      ],
-
-      :shutdown => [],
-      :ramaze_shutdown => [
-        :kill_threads,
-        lambda{
-          Inform.shutdown
-          puts("Shutdown Ramaze (it's save to kill me now if i hang)")
-        },
-        :exit
-      ],
-    }
-
-    # takes an hash of options and optionally an block that is evaled in this
-    # instance of GlobalStruct.
-
-    def setup hash = {}, &block
-      Global.instance_eval(&block) if block_given?
-      table.merge!( hash.keys_to_sym )
-    end
-
-    # just update the hash, not deleting values already set.
-    # again, takes a block, but your assignments may be
-    # overwritten if they existed before.
-
-    def update hash = {}, &block
-      old_table = table.dup
-      Global.instance_eval(&block) if block_given?
-      table.merge!( hash.keys_to_sym.merge( old_table ) )
-    end
-
-    # synonym to Global.key = value
-
-    def []=(key, value)
-      table[key.to_sym] = value
-    end
-
-    # synonym for Global.key
-
-    def [](key)
-      table[key.to_sym]
-    end
-
-    # get all the values for the given keys in the right order.
-
-    def values_at(*keys)
-      table.values_at(*keys.map(&:to_sym))
-    end
-
-    # all keys already set
-
-    def keys
-      table.keys
-    end
-
-    # iterate over the GlobalStruct, no guarantee on the order.
-
-    def each
-      table.each do |e|
-        yield(e)
-      end
-    end
-
-    def inspect
-      table.inspect
-    end
-
-    def pretty_inspect
-      table.pretty_inspect
-    end
-
-
-  def new_ostruct_member(name)
-    name = name.to_sym
-    unless self.respond_to?(name)
-      class << self; self; end.class_eval do
-        define_method(name) { @table[name] }
-        define_method(:"#{name}=") { |x| @table[name] = x }
-      end
-    end
-  end
+  GlobalDSL.option_dsl do
+    o "Set the adapter Ramaze will run on.",
+      :adapter => :webrick, :cli => [:webrick, :mongrel]
+
+    o "All running threads of Adapter will be collected here.",
+      :adapters => ThreadGroup.new
+
+    o "Set the size of Backtrace shown.",
+      :backtrace_size => 10, :cli => 10
+
+    o "Turn benchmarking every request on.",
+      :benchmarking => false, :cli => false
+
+    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 "Turn on cookies for all requests.",
+      :cookies => true, :cli => true
+
+    o "All subclasses of Controller are collected here.",
+      :controllers => Set.new
+
+    o "Start Ramaze within an IRB session",
+      :console => false, :cli => false
+
+    o "Turn on customized error pages.",
+      :error_page => true, :cli => true
+
+    o "Specify what IP Ramaze will respond to - 0.0.0.0 for all",
+      :host => "0.0.0.0", :cli => '0.0.0.0'
 
-    def new_ostruct_member(name)
-      name = name.to_sym
-      unless self.respond_to?(name)
-        meta = (class << self; self; end)
-        meta.class_eval do
-          define_method(name) do
-            sel = @table[name]
-            if sel.respond_to?(:call)
-              sel.call
-            else
-              sel
-            end
-          end
-
-          define_method(:"#{name}=") do |x|
-            sel = @table[name]
-            if sel.respond_to?(:call)
-              sel.call("#{name}=", x)
-            else
-              @table[name] = x
-            end
-          end
-        end
-      end
-    end
+    o "All paths to controllers are mapped here.",
+      :mapping => {}
+
+    o "The place ramaze was started from, useful mostly for debugging",
+      :origin => :main
+
+    o "Specify port",
+      :port => 7000, :cli => 7000
+
+    o "Specify the shadowing public directory (default in proto)",
+      :public_root => ( BASEDIR / 'proto' / 'public' )
+
+    o "Record all Request objects by assigning a filtering Proc to me.",
+      :record => false
+
+    o "Don't wait until all adapter-threads are finished or killed.",
+      :run_loose => false, :cli => false
+
+    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 "How many adapters Ramaze should spawn.",
+      :spawn => 1, :cli => 1
+
+    o "Test before start if adapters will be able to connect",
+      :test_connections => true, :cli => true
+
+    o "Specify template root for dynamic files relative to main.rb",
+      :template_root => 'template'
   end
 
-  Thread.current[:global] = GlobalStruct.new(GlobalStruct::DEFAULT)
-  Global = Thread.current[:global]
+  require 'ramaze/global/globalstruct'
+
+  Global = GlobalStruct.setup(OPTIONS)
 end