renee-core 0.4.0.pre1 → 0.4.0.pre2

data/lib/renee/core/routing.rb

@@ -40,11 +40,11 @@ module Renee
       #   end
       #
       # @api public
-      def path(p, &blk)
-        if blk
+      def path(p)
+        if block_given?
           p = p[1, p.size] if p[0] == ?/
           extension_part = detected_extension ? "|\\.#{Regexp.quote(detected_extension)}" : ""
-          part(/^\/#{Regexp.quote(p)}(?=\/|$#{extension_part})/, &blk)
+          part(/^\/#{Regexp.quote(p)}(?=\/|$#{extension_part})/) { yield }
         else
           create_chain_proxy(:path, p)
         end
@@ -87,14 +87,17 @@ module Renee
       #   GET /test/hey/there  #=> [200, {}, 'hey-there']
       #
       # @api public
-      def variable(type = nil, &blk)
-        blk ? complex_variable(type, '/', 1, &blk) : create_chain_proxy(:variable, type)
+      def variable(*types)
+        block_given? ?
+          complex_variable(types, '/', types.empty? ? 1 : types.size) { |*a| yield *a } :
+          create_chain_proxy(:variable, *types)
       end
       alias_method :var, :variable
       chainable :variable, :var
 
-      def optional_variable(type = nil, &blk)
-        blk ? complex_variable(type, '/', 0..1) { |vars| blk[vars.first] } : create_chain_proxy(:variable, type)
+      def optional_variable(type = nil)
+        block_given? ?
+          complex_variable(type, '/', 0..1) { |vars| yield vars.first } : create_chain_proxy(:variable, type)
       end
       alias_method :optional, :optional_variable
       chainable :optional, :optional_variable
@@ -102,8 +105,10 @@ module Renee
       # 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)
-        blk ? complex_variable(type, '/', count, &blk) : create_chain_proxy(:multi_variable, count, type)
+      def multi_variable(count, type = nil)
+        block_given? ?
+          complex_variable(type, '/', count) { |mv| yield mv } :
+          create_chain_proxy(:multi_variable, count, type)
       end
       alias_method :multi_var, :multi_variable
       alias_method :mvar, :multi_variable
@@ -111,8 +116,10 @@ module Renee
 
       # Same as variable except it matches indefinitely.
       # @param [Symbol] type The type to use for match.
-      def repeating_variable(type = nil, &blk)
-        blk ? complex_variable(type, '/', nil, &blk) : create_chain_proxy(:repeating_variable, type)
+      def repeating_variable(type = nil)
+        block_given? ?
+          complex_variable(type, '/', nil) { |mv| yield mv } :
+          create_chain_proxy(:repeating_variable, type)
       end
       alias_method :glob, :repeating_variable
       chainable :repeating_variable, :glob
@@ -120,8 +127,10 @@ module Renee
       # Match parts off the path as variables without a leading slash.
       # @see #variable
       # @api public
-      def partial_variable(type = nil, &blk)
-        blk ? complex_variable(type, nil, 1, &blk) : create_chain_proxy(:partial_variable, type)
+      def partial_variable(type = nil)
+        block_given? ?
+          complex_variable(type, nil, 1) { |v| yield v } :
+          create_chain_proxy(:partial_variable, type)
       end
       alias_method :part_var, :partial_variable
       chainable :partial_variable, :part_var
@@ -143,8 +152,8 @@ module Renee
       #   no_extension { |path| halt [200, {}, path] }
       #
       # @api public
-      def no_extension(&blk)
-        blk.call unless detected_extension
+      def no_extension
+        yield unless detected_extension
       end
 
       # Match any remaining path.
@@ -153,8 +162,10 @@ module Renee
       #   remainder { |path| halt [200, {}, path] }
       #
       # @api public
-      def remainder(&blk)
-        blk ? with_path_part(env['PATH_INFO']) { |var| blk.call(var) } : create_chain_proxy(:remainder)
+      def remainder
+        block_given? ?
+          with_path_part(env['PATH_INFO']) { |var| yield var } :
+          create_chain_proxy(:remainder)
       end
       alias_method :catchall, :remainder
       chainable :remainder, :catchall
@@ -165,8 +176,8 @@ module Renee
       #   get { halt [200, {}, "hello world"] }
       #
       # @api public
-      def get(&blk)
-        blk ? request_method('GET', &blk) : create_chain_proxy(:get)
+      def get
+        block_given? ? request_method('GET') { yield } : create_chain_proxy(:get)
       end
       chainable :get
 
@@ -176,8 +187,8 @@ module Renee
       #   post { halt [200, {}, "hello world"] }
       #
       # @api public
-      def post(&blk)
-        blk ? request_method('POST', &blk) : create_chain_proxy(:post)
+      def post
+        block_given? ? request_method('POST') { yield } : create_chain_proxy(:get)
       end
       chainable :post
 
@@ -187,19 +198,30 @@ module Renee
       #   put { halt [200, {}, "hello world"] }
       #
       # @api public
-      def put(&blk)
-        blk ? request_method('PUT', &blk) : create_chain_proxy(:put)
+      def put
+        block_given? ? request_method('PUT') { yield } : create_chain_proxy(:get)
       end
       chainable :put
 
+      # Respond to a PATCH request and yield the block.
+      #
+      # @example
+      #   put { halt [200, {}, "hello world"] }
+      #
+      # @api public
+      def patch
+        block_given? ? request_method('PATCH') { yield } : create_chain_proxy(:get)
+      end
+      chainable :patch
+
       # Respond to a DELETE request and yield the block.
       #
       # @example
       #   delete { halt [200, {}, "hello world"] }
       #
       # @api public
-      def delete(&blk)
-        blk ? request_method('DELETE', &blk) : create_chain_proxy(:delete)
+      def delete
+        block_given? ? request_method('DELETE') { yield } : create_chain_proxy(:get)
       end
       chainable :delete
 
@@ -209,9 +231,9 @@ module Renee
       #   complete { halt [200, {}, "hello world"] }
       #
       # @api public
-      def complete(&blk)
-        if blk
-          with_path_part(env['PATH_INFO']) { blk.call } if complete?
+      def complete
+        if block_given?
+          with_path_part(env['PATH_INFO']) { yield } if complete?
         else
           create_chain_proxy(:complete)
         end
@@ -227,7 +249,8 @@ module Renee
       #
       # @api public
       def complete?
-        (detected_extension and env['PATH_INFO'] =~ /^\/?(\.#{Regexp.quote(detected_extension)}\/?)?$/) || (detected_extension.nil? and env['PATH_INFO'] =~ /^\/?$/)
+        (detected_extension and env['PATH_INFO'] =~ /^\/?(\.#{Regexp.quote(detected_extension)}\/?)?$/) ||
+          (detected_extension.nil? and env['PATH_INFO'] =~ /^\/?$/)
       end
 
       # Match only when the path is ''.
@@ -236,10 +259,10 @@ module Renee
       #   empty { halt [200, {}, "hello world"] }
       #
       # @api public
-      def empty(&blk)
-        if blk
+      def empty
+        if block_given?
           if env['PATH_INFO'] == ''
-            with_path_part(env['PATH_INFO']) { blk.call }
+            with_path_part(env['PATH_INFO']) { yield }
           end
         else
           create_chain_proxy(:empty)
@@ -249,11 +272,10 @@ module Renee
 
       private
       def complex_variable(type, prefix, count)
-        matcher = variable_matcher_for_type(type)
         path = env['PATH_INFO'].dup
         vals = []
-        var_index = 0
-        variable_matching_loop(count) do
+        variable_matching_loop(count) do |idx|
+          matcher = variable_matcher_for_type(type.respond_to?(:at) ? type.at(idx) : type)
           path.start_with?(prefix) ? path.slice!(0, prefix.size) : break if prefix
           if match = matcher[path]
             path.slice!(0, match.first.size)
@@ -272,9 +294,9 @@ module Renee
 
       def variable_matching_loop(count)
         case count
-        when Range then count.max.times { break unless yield }
-        when nil   then loop { break unless yield }
-        else            count.times { break unless yield }
+        when Range then count.max.times { |i| break unless yield i }
+        when nil   then i = 0; loop { break unless yield i; i+= 1 }
+        else            count.times { |i| break unless yield i }
         end
       end
 
@@ -304,14 +326,19 @@ module Renee
         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
+        @requested_http_methods.clear
         yield script_part
         raise NotMatchedError
       end
 
       def request_method(method)
-        if env['REQUEST_METHOD'] == method && complete?
-          yield
-          raise NotMatchedError
+        if complete?
+          if env['REQUEST_METHOD'] == method
+            yield
+            raise NotMatchedError
+          else
+            @requested_http_methods << method
+          end
         end
       end
     end

data/lib/renee/core/transform.rb

@@ -13,6 +13,64 @@ module Renee
           m.first == value ? m.last : nil
         end
       end
+
+      # Class used for variable matching.
+      class Matcher
+        attr_accessor :name
+
+        # @param [Regexp] matcher The regexp matcher to determine what is part of the variable.
+        def initialize(matcher)
+          @matcher = matcher
+        end
+
+        # Used to specific the error handler if the matcher doesn't match anything. By default, there is no error handler.
+        # @yield The block to be executed it fails to match.
+        def on_error(&blk)
+          @error_handler = blk
+          self
+        end
+
+        # Used to transform the value matched.
+        # @yield TODO
+        def on_transform(&blk)
+          @transform_handler = blk
+          self
+        end
+
+        # Convienence method to creating halting error handler.
+        # @param [Symbol, Integer] error_code The HTTP code to halt with.
+        # @see #interpret_response
+        def halt_on_error!(error_code = :bad_request)
+          on_error { halt error_code }
+          self
+        end
+
+        # Matcher for string
+        # @param [String] val The value to attempt to match on.
+        # @raise [ClientError] If the match fails to match and there is an error handler defined.
+        def [](val)
+          match = nil
+          case @matcher
+          when Array
+            match = nil
+            @matcher.find { |m| match = m[val] }
+          else
+            if match = /^#{@matcher.to_s}/.match(val)
+              match = [match[0]]
+              match << @transform_handler.call(match.first) if @transform_handler
+              match
+            end
+          end
+          if match
+            match
+          elsif @error_handler
+            raise ClientError.new("There was an error interpreting the value #{val.inspect} for #{name.inspect}", &@error_handler)
+          end
+        end
+      end
+
+      # Matcher for Integers
+      IntegerMatcher = Matcher.new(/\d+/).on_transform{|v| Integer(v)}
     end
   end
 end

data/lib/renee/core/version.rb

@@ -0,0 +1,5 @@
+module Renee
+  class Core
+    VERSION = '0.4.0.pre2'
+  end
+end

data/lib/renee/core.rb

@@ -1,25 +1,21 @@
 require 'rack'
 
-require 'renee/version'
-require 'renee/core/matcher'
+require 'renee/core/version'
+require 'renee/core/transform'
 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
   # @example
   #     Renee.core { path('/hello') { halt :ok } }
-  def self.core(&blk)
+  def self.core(&app)
     cls = Class.new(Renee::Core)
-    cls.app(&blk) if blk
+    cls.run(&app) if app
     cls
   end
 
@@ -27,12 +23,12 @@ 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)
 
+    # Error raised if respond! or respond is used and no body is set.
+    NoResponseSetError = Class.new(RuntimeError)
+
     # Class methods that are included in new instances of {Core} 
     module ClassMethods
       include Plugins
@@ -46,12 +42,22 @@ module Renee
         new.call(env)
       end
 
+      # Specify a middleware to use before calling your application.
+      def use(mw, *args, &blk)
+        middlewares << [mw, args, blk]
+      end
+
+      # Retreive the list of currently available middlewares.
+      def middlewares
+        @middlewares ||= []
+      end
+
       # Allows you to set the #application_block on your class.
       # @yield The application block
-      def app(&app)
+      def run(&app)
         @application_block = app
         setup do
-          register_variable_type :integer, IntegerMatcher
+          register_variable_type :integer, Transform::IntegerMatcher
           register_variable_type :int, :integer
         end
       end
@@ -73,26 +79,68 @@ module Renee
       # @return [Renee::Core::Matcher] A matcher
       def register_variable_type(name, matcher)
         matcher = case matcher
-        when Matcher then matcher
-        when Array   then Matcher.new(matcher.map{|m| variable_types[m]})
-        when Symbol  then variable_types[matcher]
-        else              Matcher.new(matcher)
+        when Transform::Matcher then matcher
+        when Array              then Transform::Matcher.new(matcher.map{|m| variable_types[m]})
+        when Symbol             then variable_types[matcher]
+        else                         Transform::Matcher.new(matcher)
         end
         matcher.name = name
         variable_types[name] = matcher
       end
     end
 
+    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
+          @requested_http_methods = []
+          @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)
+              raise NotMatchedError
+            rescue ClientError => e
+              e.response ? instance_eval(&e.response) : halt("There was an error with your request", 400)
+            rescue NotMatchedError => e
+              unless @requested_http_methods.empty?
+                throw :halt, 
+                  Rack::Response.new(
+                    "Method #{request.request_method} unsupported, use #{@requested_http_methods.join(", ")} instead", 405,
+                    {'Allow' => @requested_http_methods.join(", ")}).finish
+              end
+            end
+            Rack::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
+
     include Chaining
-    include RequestContext
     include Routing
     include Responding
     include RackInteraction
     include Transform
-    include EnvAccessors
 
-    class << self
-      include ClassMethods
-    end
+    extend ClassMethods
   end
 end

data/renee-core.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "renee/core/version"
+
+Gem::Specification.new do |s|
+  s.name        = "renee-core"
+  s.version     = Renee::Core::VERSION
+  s.authors     = ["Josh Hull", "Nathan Esquenazi", "Arthur Chiu"]
+  s.email       = ["joshbuddy@gmail.com", "nesquena@gmail.com", "mr.arthur.chiu@gmail.com"]
+  s.homepage    = "http://reneerb.com"
+  s.summary     = %q{The super-friendly rack helpers}
+  s.description = %q{The super-friendly rack helpers.}
+
+  s.rubyforge_project = "renee-core"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test`.split("\n") + ["test/test_helper.rb"]
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency 'rack', ">= 1.3.0"
+
+  s.add_development_dependency 'minitest', "~> 2.11.1"
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency "rack-test", ">= 0.5.0"
+  s.add_development_dependency "rake"
+end

data/test/{renee-core/chaining_test.rb → chaining_test.rb}

@@ -1,7 +1,6 @@
 require File.expand_path('../test_helper', __FILE__)
 
 describe "Route chaining" do
-
   it "should chaining" do
     type = { 'Content-Type' => 'text/plain' }
     mock_app do

data/test/{renee-core/responding_test.rb → responding_test.rb}

@@ -20,6 +20,27 @@ describe Renee::Core::Responding do
       assert_equal 'Status code 404', response.body
     end
 
+    it "should respond with a 404 if the path isn't matched" do
+      mock_app do
+        path('hello') do
+          halt :ok
+        end
+      end
+      get '/'
+      assert_equal 404,         response.status
+      assert_equal 'Not found', response.body
+    end
+
+    it "should respond with a 405 if the path is matched but the request method isn't" do
+      mock_app do
+        get {}
+        post {}
+      end
+      put '/'
+      assert_equal 405,         response.status
+      assert_equal 'GET, POST', response.headers['Allow']
+    end
+
     it "should render from a string" do
       mock_app do
         path('/') { halt "hello!" }
@@ -43,7 +64,7 @@ describe Renee::Core::Responding do
         path('/') { halt :payment_required, "hello!" }
       end
       get '/'
-      assert_equal 403,      response.status
+      assert_equal 402,      response.status
       assert_equal 'hello!', response.body
     end
 
@@ -92,6 +113,15 @@ describe Renee::Core::Responding do
       assert_equal "bar",   response.headers["foo"]
       assert_equal "hello!", response.body
     end # respond
+
+    it "should raise a NoResponseSetError if you respond without any values" do
+      mock_app do
+        get do
+          respond!
+        end
+      end
+      assert_raises(Renee::Core::NoResponseSetError) { get('/') }
+    end # respond
   end
 
   describe "#redirect" do

data/test/test_helper.rb

@@ -1,3 +1,5 @@
+$: << File.expand_path('../../lib', __FILE__)
+require 'renee/core'
 require 'rubygems'
 gem 'minitest'
 require 'minitest/autorun'

data/test/{renee-core/variable_type_test.rb → variable_type_test.rb}

@@ -19,7 +19,7 @@ describe Renee::Core::Matcher do
         halt i.inspect
       end
     }.setup {
-      register_variable_type(:symbol, /[a-z_]+/).on_transform{|v| v.to_sym}.raise_on_error!
+      register_variable_type(:symbol, /[a-z_]+/).on_transform{|v| v.to_sym}.halt_on_error!
     }
     get '/123'
     assert_equal 400, response.status