renee-core 0.3.11 → 0.4.0.pre1

data/lib/{renee_core.rb → renee/core.rb}

@@ -1,15 +1,17 @@
 require 'rack'
-require 'renee_core/matcher'
-require 'renee_core/chaining'
-require 'renee_core/response'
-require 'renee_core/url_generation'
-require 'renee_core/exceptions'
-require 'renee_core/rack_interaction'
-require 'renee_core/request_context'
-require 'renee_core/transform'
-require 'renee_core/routing'
-require 'renee_core/responding'
-require 'renee_core/env_accessors'
+
+require 'renee/version'
+require 'renee/core/matcher'
+require 'renee/core/chaining'
+require 'renee/core/response'
+require 'renee/core/exceptions'
+require 'renee/core/rack_interaction'
+require 'renee/core/request_context'
+require 'renee/core/transform'
+require 'renee/core/routing'
+require 'renee/core/responding'
+require 'renee/core/env_accessors'
+require 'renee/core/plugins'
 
 # Top-level Renee constant
 module Renee
@@ -25,9 +27,15 @@ module Renee
   # For convience you can also used a method named #Renee
   # for decalaring new instances.
   class Core
+    # Current version of Renee::Core
+    VERSION = Renee::VERSION
+
+    # Error raised if routing fails. Use #continue_routing to continue routing.
+    NotMatchedError = Class.new(RuntimeError)
+
     # Class methods that are included in new instances of {Core} 
     module ClassMethods
-      include URLGeneration
+      include Plugins
 
       # The application block used to create your application.
       attr_reader :application_block
@@ -46,7 +54,6 @@ module Renee
           register_variable_type :integer, IntegerMatcher
           register_variable_type :int, :integer
         end
-        self
       end
 
       # Runs class methods on your application.

data/lib/{renee_core → renee/core}/chaining.rb

@@ -13,29 +13,28 @@ module Renee
     module Chaining
       # @private
       class ChainingProxy
-        def initialize(target, m, args)
+        def initialize(target, m, args = nil)
           @target, @calls = target, []
           @calls << [m, args]
         end
 
         def method_missing(m, *args, &blk)
           @calls << [m, args]
-          if blk.nil? && @target.class.private_method_defined?(:"#{m}_without_chain")
+          if blk.nil? && @target.class.respond_to?(:chainable?) && @target.class.chainable?(m)
             self
           else
             inner_args = []
             ret = nil
             callback = proc do |*callback_args|
               inner_args.concat(callback_args)
-              if @calls.size == 0 and blk
-                blk.call(*inner_args)
+              if @calls.size == 0
+                ret = blk.call(*inner_args) if blk
               else
                 call = @calls.shift
-                ret = @target.send(call.at(0), *call.at(1), &callback)
+                ret = call.at(1) ? @target.send(call.at(0), *call.at(1), &callback) : @target.send(call.at(0), &callback) 
               end
             end
-            call = @calls.shift
-            ret = @target.send(call.at(0), *call.at(1), &callback)
+            ret = callback.call
             ret
           end
         end
@@ -43,17 +42,20 @@ module Renee
 
       # @private
       module ClassMethods
-        def chain_method(*methods)
+        def chainable?(m)
+          method_defined?(:"#{m}_chainable")
+        end
+
+        def chainable(*methods)
           methods.each do |m|
-            class_eval <<-EOT, __FILE__, __LINE__ + 1
-              alias_method :#{m}_without_chain, :#{m}
-              def #{m}(*args, &blk)
-                blk.nil? ? ChainingProxy.new(self, #{m.inspect}, args) : #{m}_without_chain(*args, &blk)
-              end
-              private :#{m}_without_chain
-            EOT
+            define_method(:"#{m}_chainable") { }
           end
         end
+
+      end
+
+      def create_chain_proxy(method_name, *args)
+        ChainingProxy.new(self, method_name, args)
       end
 
       def self.included(o)

data/lib/{renee_core → renee/core}/env_accessors.rb

@@ -5,9 +5,9 @@ module Renee
 
       # Exception for attempting to define an env accessor cannot be written as a method name.
       # @example
-      #   env_accessor "current.user" # raises InvalidEnvName
+      #   env_accessor "current.user" # raises InvalidEnvNameError
       #   env_accessor "current.user" => :current_user # this works
-      InvalidEnvName = Class.new(RuntimeError)
+      InvalidEnvNameError = Class.new(RuntimeError)
 
       # Class-methods included by this module.
       module ClassMethods
@@ -55,7 +55,7 @@ module Renee
                 yield k, v
               end
             else
-              raise InvalidEnvName, "Called env attr for #{a.inspect}, to use this, call your env method like this. env_reader #{a.inspect} => #{a.to_s.gsub(/-\./, '_').to_sym.inspect}" if a.to_s[/[-\.]/]
+              raise InvalidEnvNameError, "Called env attr for #{a.inspect}, to use this, call your env method like this. env_reader #{a.inspect} => #{a.to_s.gsub(/-\./, '_').to_sym.inspect}" if a.to_s[/[-\.]/]
               yield a, a.to_sym
             end
           end

data/lib/renee/core/plugins.rb

@@ -0,0 +1,31 @@
+module Renee
+  class Core
+    module Plugins
+      attr_reader :init_blocks, :before_blocks, :after_blocks
+
+      def on_init(&blk)
+        init_blocks << blk
+      end
+
+      def init_blocks
+        (@init_blocks ||= [])
+      end
+
+      def on_before(&blk)
+        before_blocks << blk
+      end
+
+      def before_blocks
+        (@before_blocks ||= [])
+      end
+
+      def on_after(&blk)
+        before_blocks << blk
+      end
+
+      def after_blocks
+        (@after_blocks ||= [])
+      end
+    end
+  end
+end

data/lib/renee/core/request_context.rb

@@ -0,0 +1,56 @@
+module Renee
+  class Core
+    module ClassMethods
+      def use(mw, *args, &blk)
+        middlewares << [mw, args, blk]
+      end
+
+      def middlewares
+        @middlewares ||= []
+      end
+    end
+
+    # This module deals with the Rack#call compilance. It defines #call and also defines several critical methods
+    # used by interaction by other application modules.
+    module RequestContext
+      attr_reader :env, :request, :detected_extension
+
+      # Provides a rack interface compliant call method.
+      # @param[Hash] env The rack environment.
+      def call(e)
+        initialize_plugins
+        idx = 0
+        next_app = proc do |env|
+          if idx == self.class.middlewares.size
+            @env, @request = env, Rack::Request.new(env)
+            @detected_extension = env['PATH_INFO'][/\.([^\.\/]+)$/, 1]
+            # TODO clear template cache in development? `template_cache.clear`
+            out = catch(:halt) do
+              begin
+                self.class.before_blocks.each { |b| instance_eval(&b) }
+                instance_eval(&self.class.application_block)
+              rescue ClientError => e
+                e.response ? instance_eval(&e.response) : halt("There was an error with your request", 400)
+              rescue NotMatchedError => e
+                # unmatched, continue on
+              end
+              Renee::Core::Response.new("Not found", 404).finish
+            end
+            self.class.after_blocks.each { |a| out = instance_exec(out, &a) }
+            out
+          else
+            middleware = self.class.middlewares[idx]
+            idx += 1
+            middleware[0].new(next_app, *middleware[1], &middleware[2]).call(env)
+          end
+        end
+        next_app[e]
+      end # call
+
+      def initialize_plugins
+        self.class.init_blocks.each { |init_block| self.class.class_eval(&init_block) }
+        self.class.send(:define_method, :initialize_plugins) { }
+      end
+    end
+  end
+end

data/lib/{renee_core → renee/core}/responding.rb

@@ -42,7 +42,9 @@ module Renee
       #  respond("Hello", 200, "foo" => "bar")
       #
       def respond(body=[], status=200, header={}, &blk)
-        Renee::Core::Response.new(body, status, header).tap { |r| r.instance_eval(&blk) if block_given? }.finish
+        response = Renee::Core::Response.new(body, status, header)
+        response.instance_eval(&blk) if block_given?
+        response.finish
       end
 
       ##

data/lib/{renee_core → renee/core}/routing.rb

@@ -4,6 +4,26 @@ module Renee
     module Routing
       include Chaining
 
+      # Allow continued routing if a routing block fails to match
+      # 
+      # @param [Boolean] val
+      #   indicate if continued routing should be allowed.
+      #
+      # @api public
+      def continue_routing
+        if block_given?
+          original_env = @env.dup
+          begin
+            yield
+          rescue NotMatchedError
+            @env = original_env
+          end
+        else
+          create_chain_proxy(:continue_routing)
+        end
+      end
+      chainable :continue_routing
+
       # Match a path to respond to.
       #
       # @param [String] p
@@ -21,27 +41,27 @@ module Renee
       #
       # @api public
       def path(p, &blk)
-        p = p[1, p.size] if p[0] == ?/
-        extension_part = detected_extension ? "|\\.#{Regexp.quote(detected_extension)}" : ""
-        part(/^\/#{Regexp.quote(p)}(?=\/|$#{extension_part})/, &blk)
-      end
-      chain_method :path
-
-      # Like #path, but requires the entire path to be consumed.
-      # @see #path
-      def whole_path(p, &blk)
-        path(p) { complete(&blk) }
+        if blk
+          p = p[1, p.size] if p[0] == ?/
+          extension_part = detected_extension ? "|\\.#{Regexp.quote(detected_extension)}" : ""
+          part(/^\/#{Regexp.quote(p)}(?=\/|$#{extension_part})/, &blk)
+        else
+          create_chain_proxy(:path, p)
+        end
       end
-      chain_method :whole_path
+      chainable :path
 
       # Like #path, but doesn't look for leading slashes.
-      def part(p, &blk)
-        p = /^\/?#{Regexp.quote(p)}/ if p.is_a?(String)
-        if match = env['PATH_INFO'][p]
-          with_path_part(match) { blk.call }
+      def part(p)
+        if block_given?
+          p = /^\/?#{Regexp.quote(p)}/ if p.is_a?(String)
+          if match = env['PATH_INFO'][p]
+            with_path_part(match) { yield }
+          end
+        else
+          create_chain_proxy(:part, p)
         end
       end
-      chain_method :part
 
       # Match parts off the path as variables. The parts matcher can conform to either a regular expression, or be an Integer, or
       # simply a String.
@@ -68,54 +88,54 @@ module Renee
       #
       # @api public
       def variable(type = nil, &blk)
-        complex_variable(type, '/', 1, &blk)
+        blk ? complex_variable(type, '/', 1, &blk) : create_chain_proxy(:variable, type)
       end
       alias_method :var, :variable
-      chain_method :variable, :var
+      chainable :variable, :var
+
+      def optional_variable(type = nil, &blk)
+        blk ? complex_variable(type, '/', 0..1) { |vars| blk[vars.first] } : create_chain_proxy(:variable, type)
+      end
+      alias_method :optional, :optional_variable
+      chainable :optional, :optional_variable
 
       # Same as variable except you can match multiple variables with the same type.
       # @param [Range, Integer] count The number of parameters to capture.
       # @param [Symbol] type The type to use for match.
       def multi_variable(count, type = nil, &blk)
-        complex_variable(type, '/', count, &blk)
+        blk ? complex_variable(type, '/', count, &blk) : create_chain_proxy(:multi_variable, count, type)
       end
       alias_method :multi_var, :multi_variable
       alias_method :mvar, :multi_variable
-      chain_method :multi_variable, :multi_var, :mvar
+      chainable :multi_variable, :multi_var, :mvar
 
       # Same as variable except it matches indefinitely.
       # @param [Symbol] type The type to use for match.
       def repeating_variable(type = nil, &blk)
-        complex_variable(type, '/', nil, &blk)
+        blk ? complex_variable(type, '/', nil, &blk) : create_chain_proxy(:repeating_variable, type)
       end
       alias_method :glob, :repeating_variable
-      chain_method :repeating_variable, :glob
+      chainable :repeating_variable, :glob
 
       # Match parts off the path as variables without a leading slash.
       # @see #variable
       # @api public
       def partial_variable(type = nil, &blk)
-        complex_variable(type, nil, 1, &blk)
+        blk ? complex_variable(type, nil, 1, &blk) : create_chain_proxy(:partial_variable, type)
       end
       alias_method :part_var, :partial_variable
-      chain_method :partial_variable, :part_var
+      chainable :partial_variable, :part_var
 
-      # Match an extension.
+      # Returns the matched extension. If no extension is present, returns `nil`.
       #
       # @example
-      #   extension('html') { |path| halt [200, {}, path] }
+      #   halt [200, {}, path] if extension == 'html'
       #
       # @api public
-      def extension(ext, &blk)
-        if detected_extension && match = detected_extension[ext]
-          if match == detected_extension
-            (ext_match = env['PATH_INFO'][/\/?\.#{match}/]) ?
-              with_path_part(ext_match, &blk) : blk.call
-          end
-        end
+      def extension
+        detected_extension
       end
       alias_method :ext, :extension
-      chain_method :extension, :ext
 
       # Match no extension.
       #
@@ -124,9 +144,8 @@ module Renee
       #
       # @api public
       def no_extension(&blk)
-        blk.call if detected_extension.nil?
+        blk.call unless detected_extension
       end
-      chain_method :no_extension
 
       # Match any remaining path.
       #
@@ -135,10 +154,10 @@ module Renee
       #
       # @api public
       def remainder(&blk)
-        with_path_part(env['PATH_INFO']) { |var| blk.call(var) }
+        blk ? with_path_part(env['PATH_INFO']) { |var| blk.call(var) } : create_chain_proxy(:remainder)
       end
       alias_method :catchall, :remainder
-      chain_method :remainder, :catchall
+      chainable :remainder, :catchall
 
       # Respond to a GET request and yield the block.
       #
@@ -146,10 +165,10 @@ module Renee
       #   get { halt [200, {}, "hello world"] }
       #
       # @api public
-      def get(path = nil, &blk)
-        request_method('GET', path, &blk)
+      def get(&blk)
+        blk ? request_method('GET', &blk) : create_chain_proxy(:get)
       end
-      chain_method :get
+      chainable :get
 
       # Respond to a POST request and yield the block.
       #
@@ -157,10 +176,10 @@ module Renee
       #   post { halt [200, {}, "hello world"] }
       #
       # @api public
-      def post(path = nil, &blk)
-        request_method('POST', path, &blk)
+      def post(&blk)
+        blk ? request_method('POST', &blk) : create_chain_proxy(:post)
       end
-      chain_method :post
+      chainable :post
 
       # Respond to a PUT request and yield the block.
       #
@@ -168,10 +187,10 @@ module Renee
       #   put { halt [200, {}, "hello world"] }
       #
       # @api public
-      def put(path = nil, &blk)
-        request_method('PUT', path, &blk)
+      def put(&blk)
+        blk ? request_method('PUT', &blk) : create_chain_proxy(:put)
       end
-      chain_method :put
+      chainable :put
 
       # Respond to a DELETE request and yield the block.
       #
@@ -179,10 +198,10 @@ module Renee
       #   delete { halt [200, {}, "hello world"] }
       #
       # @api public
-      def delete(path = nil, &blk)
-        request_method('DELETE', path, &blk)
+      def delete(&blk)
+        blk ? request_method('DELETE', &blk) : create_chain_proxy(:delete)
       end
-      chain_method :delete
+      chainable :delete
 
       # Match only when the path is either '' or '/'.
       #
@@ -191,66 +210,42 @@ module Renee
       #
       # @api public
       def complete(&blk)
-        if env['PATH_INFO'] == '/' or env['PATH_INFO'] == ''
-          with_path_part(env['PATH_INFO']) { blk.call }
+        if blk
+          with_path_part(env['PATH_INFO']) { blk.call } if complete?
+        else
+          create_chain_proxy(:complete)
         end
       end
-      chain_method :complete
+      chainable :complete
 
-      # Match only when the path is ''.
+      # Test if the path has been consumed
       #
       # @example
-      #   empty { halt [200, {}, "hello world"] }
+      #   if complete?
+      #     halt "Hey, the path is done"
+      #   end
       #
       # @api public
-      def empty(&blk)
-        if env['PATH_INFO'] == ''
-          with_path_part(env['PATH_INFO']) { blk.call }
-        end
+      def complete?
+        (detected_extension and env['PATH_INFO'] =~ /^\/?(\.#{Regexp.quote(detected_extension)}\/?)?$/) || (detected_extension.nil? and env['PATH_INFO'] =~ /^\/?$/)
       end
-      chain_method :empty
 
-      # Match variables within the query string.
-      #
-      # @param [Array, Hash] q
-      #   Either an array or hash of things to match query string variables. If given
-      #   an array, if you pass the values for each key as parameters to the block given.
-      #   If given a hash, then every value must be able to be matched by a registered type.
-      #
-      # @example
-      #   query(:key => :integer) { |h| halt [200, {}, "hello world #{h[:key]}"] }
+      # Match only when the path is ''.
       #
       # @example
-      #   query(:key) { |val| halt [200, {}, "key is #{val}"] }
+      #   empty { halt [200, {}, "hello world"] }
       #
       # @api public
-      def query(q, &blk)
-        case q
-        when Hash  then blk.call(Hash[q.map{|(k, v)| [k, transform(v, request[k.to_s]) || return]}])
-        when Array then blk.call(*q.map{|qk| request[qk.to_s] or return })
-        else            query([q], &blk)
+      def empty(&blk)
+        if blk
+          if env['PATH_INFO'] == ''
+            with_path_part(env['PATH_INFO']) { blk.call }
+          end
+        else
+          create_chain_proxy(:empty)
         end
       end
-      chain_method :query
-
-      # Yield block if the query string matches.
-      #
-      # @param [String] qs
-      #   The query string to match.
-      #
-      # @example
-      #   path 'test' do
-      #     query_string 'foo=bar' do
-      #       halt [200, {}, 'matched']
-      #     end
-      #   end
-      #   GET /test?foo=bar #=> 'matched'
-      #
-      # @api public
-      def query_string(qs, &blk)
-        blk.call if qs === env['QUERY_STRING']
-      end
-      chain_method :query_string
+      chainable :empty
 
       private
       def complex_variable(type, prefix, count)
@@ -306,17 +301,19 @@ module Renee
       end
 
       def with_path_part(part)
-        old_path_info, old_script_name = env['PATH_INFO'], env['SCRIPT_NAME']
-        script_part, env['PATH_INFO'] = old_path_info[0, part.size], old_path_info[part.size, old_path_info.size]
+        script_part = env['PATH_INFO'][0, part.size]
+        env['PATH_INFO'] = env['PATH_INFO'].slice(part.size, env['PATH_INFO'].size)
         env['SCRIPT_NAME'] += script_part
         yield script_part
-        env['PATH_INFO'], env['SCRIPT_NAME'] = old_path_info, old_script_name
+        raise NotMatchedError
       end
 
-      def request_method(method, path = nil, &blk)
-        path ? whole_path(path) { blk.call } : complete { blk.call } if env['REQUEST_METHOD'] == method
+      def request_method(method)
+        if env['REQUEST_METHOD'] == method && complete?
+          yield
+          raise NotMatchedError
+        end
       end
-      chain_method :request_method
     end
   end
 end