renee-core 0.0.1 → 0.1.0

data/.yardopts

@@ -0,0 +1,6 @@
+--output-dir ../doc/core
+--readme README.md
+--no-private
+--title Renee Core
+--markup markdown
+'lib/**/*.rb'

data/README.md

@@ -104,7 +104,7 @@ and even explicitly cast your variable types:
 
 ```ruby
 path('blog') {
-  var :type => Integer do |id|
+  var :integer do |id|
     get { halt "path is /blog/#{id} and id is an integer" }
   end
 end

data/Rakefile

@@ -1,8 +1,14 @@
 require "bundler/gem_tasks"
 require 'rake/testtask'
+require 'yard'
 
 Rake::TestTask.new do |t|
   t.libs.push "lib"
   t.test_files = FileList[File.expand_path('../test/**/*_test.rb', __FILE__)]
   t.verbose = true
 end
+
+desc "Generate documentation for the Padrino framework"
+task :doc do
+  YARD::CLI::Yardoc.new.run
+end

data/lib/renee-core/application/chaining.rb

@@ -0,0 +1,61 @@
+require 'set'
+
+class Renee
+  class Core
+    class Application
+      module Chaining
+        private
+        class ChainingProxy
+          def initialize(target, proxy_blk)
+            @target, @proxy_blk, @calls = target, proxy_blk, []
+          end
+
+          def method_missing(m, *args, &blk)
+            @calls << [m, *args]
+            if blk.nil? && @target.class.private_method_defined?(:"#{m}_without_chain")
+              self
+            else
+              ret = nil
+              @proxy_blk.call(proc do |*inner_args|
+                callback = proc do |*callback_args|
+                  inner_args.concat(callback_args)
+                  if @calls.size == 0
+                    return blk.call(*inner_args) if blk
+                  else
+                    call = @calls.shift
+                    ret = @target.send(call.at(0), *call.at(1), &callback)
+                  end
+                end
+                call = @calls.shift
+                ret = @target.send(call.at(0), *call.at(1), &callback)
+              end)
+              ret
+            end
+          end
+        end
+
+        module ClassMethods
+          def chain_method(*methods)
+            methods.each do |m|
+              class_eval <<-EOT, __FILE__, __LINE__ + 1
+                alias_method :#{m}_without_chain, :#{m}
+                def #{m}(*args, &blk)
+                  chain(blk) { |subblk| #{m}_without_chain(*args, &subblk) }
+                end
+                private :#{m}_without_chain
+              EOT
+            end
+          end
+        end
+
+        def chain(blk, &proxy)
+          blk ? yield(blk) : ChainingProxy.new(self, proxy)
+        end
+
+        def self.included(o)
+          o.extend(ClassMethods)
+        end
+      end
+    end
+  end
+end

data/lib/renee-core/application/rack_interaction.rb

@@ -21,6 +21,7 @@ class Renee
         #     get { halt run proc { |env| Renee::Core::Response.new("Hello!").finish } }
         #
         def run(app = nil, &blk)
+          raise "You cannot supply both a block and an app" unless app.nil? ^ blk.nil?
           (app || blk).call(env)
         end
 
@@ -31,7 +32,7 @@ class Renee
         #     get { run proc { |env| Renee::Core::Response.new("Hello!").finish } }
         #
         def run!(*args)
-          halt! run(*args)
+          halt run(*args)
         end
       end
     end

data/lib/renee-core/application/request_context.rb

@@ -14,7 +14,14 @@ class Renee
           @detected_extension = env['PATH_INFO'][/\.([^\.\/]+)$/, 1]
           @is_index_request = env['PATH_INFO'][/^\/?$/]
           # TODO clear template cache in development? `template_cache.clear`
-          catch(:halt) { instance_eval(&application_block); Renee::Core::Response.new("Not found", 404).finish }
+          catch(:halt) do
+            begin
+              instance_eval(&application_block)
+            rescue ClientError => e
+              e.response ? instance_eval(&e.response) : halt("There was an error with your request", 400)
+            end
+            Renee::Core::Response.new("Not found", 404).finish
+          end
         end # call
       end
     end

data/lib/renee-core/application/responding.rb

@@ -3,10 +3,9 @@ class Renee
     class Application
       # Collection of useful methods for responding within a {Renee::Core} app.
       module Responding
-
         # Codes used by Symbol lookup in interpret_response.
         # @example
-        #   halt! :unauthorized # would return a 401.
+        #   halt :unauthorized # would return a 401.
         #
         HTTP_CODES = {
           :ok => 200,
@@ -24,20 +23,10 @@ class Renee
           :error => 500,
           :not_implemented => 501}.freeze
 
-        # Halts current processing to the top-level calling Renee application and uses that as a response. This method requies that
-        # the PATH_INFO be completely consumed.
+        # Halts current processing to the top-level calling Renee application and uses that as a response.
         # @param [Object...] response The response to use.
         # @see #interpret_response
         def halt(*response)
-          raise "PATH_INFO hasn't been entirely consumed, you still have #{env['PATH_INFO'].inspect} left. Try putting a #remainder block around it. " if env['PATH_INFO'] != ''
-          halt! *response
-        end
-
-        # Halts current processing to the top-level calling Renee application and uses that as a response. Unlike #halt, this does
-        # not require the path to be consumed.
-        # @param [Object...] response The response to use.
-        # @see #interpret_response
-        def halt!(*response)
           throw :halt, interpret_response(response.size == 1 ? response.first : response)
         end
 
@@ -90,6 +79,7 @@ class Renee
           when String  then Renee::Core::Response.new(response).finish
           when Integer then Renee::Core::Response.new("Status code #{response}", response).finish
           when Symbol  then interpret_response(HTTP_CODES[response] || response.to_s)
+          when Proc    then instance_eval(&response)
           else              interpret_response(response.to_s)
           end
         end

data/lib/renee-core/application/routing.rb

@@ -3,6 +3,8 @@ class Renee
     class Application
       # Collection of useful methods for routing within a {Renee::Core} app.
       module Routing
+        include Chaining
+
         # Match a path to respond to.
         #
         # @param [String] p
@@ -21,14 +23,17 @@ class Renee
         # @api public
         def path(p, &blk)
           p = p[1, p.size] if p[0] == ?/
-          part(/^\/#{Regexp.quote(p)}(\/?$)?/, &blk)
+          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) }
         end
+        chain_method :whole_path
 
         # Like #path, but doesn't automatically match trailing-slashes.
         # @see #path
@@ -36,56 +41,69 @@ class Renee
           p = p[1, part.size] if p[0] == ?/
           part(/^\/#{Regexp.quote(p)}/, &blk)
         end
+        chain_method :exact_path
 
         # Like #path, doesn't look for leading slashes.
-        def part(p)
+        def part(p, &blk)
           p = /\/?#{Regexp.quote(p)}/ if p.is_a?(String)
           if match = env['PATH_INFO'][p]
-            with_path_part(match) { yield }
+            with_path_part(match) { blk.call }
           end
         end
+        chain_method :part
 
-        # Match parts off the path as variables.
+        # 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.
+        # @param[Object] type the type of object to match for. If you supply Integer, this will only match integers in addition to
+        #                     casting your variable for you.
+        # @param[Object] default the default value to use if your param cannot be successfully matched.
         #
         # @example
         #   path '/' do
-        #     variable { |id| halt [200, {}, id }
+        #     variable { |id| halt [200, {}, id] }
         #   end
         #   GET /hey  #=> [200, {}, 'hey']
         #
+        # @example
+        #   path '/' do
+        #     variable(:integer) { |id| halt [200, {}, "This is a numeric id: #{id}"] }
+        #   end
+        #   GET /123  #=> [200, {}, 'This is a numeric id: 123']
+        #
+        # @example
         #   path '/test' do
         #     variable { |foo, bar| halt [200, {}, "#{foo}-#{bar}"] }
         #   end
         #   GET /test/hey/there  #=> [200, {}, 'hey-there']
         #
         # @api public
-        def variable(*args, &blk)
-          args << {} unless args.last.is_a?(Hash)
-          args.last[:prepend] = '/'
-          partial_variable(*args, &blk)
+        def variable(type = nil, &blk)
+          complex_variable(type, '/', 1, &blk)
         end
         alias_method :var, :variable
+        chain_method :variable, :var
+
+        def multi_variable(count, type = nil, &blk)
+          complex_variable(type, '/', count, &blk)
+        end
+        alias_method :multi_var, :multi_variable
+        alias_method :mvar, :multi_variable
+        chain_method :multi_variable, :multi_var, :mvar
+
+        def repeating_variable(type = nil, &blk)
+          complex_variable(type, '/', nil, &blk)
+        end
+        alias_method :glob, :repeating_variable
+        chain_method :repeating_variable, :glob
 
         # Match parts off the path as variables without a leading slash.
         # @see #variable
         # @api public
-        def partial_variable(*args, &blk)
-          opts = args.last.is_a?(Hash) ? args.pop : nil
-          type = args.first || opts && opts[:type]
-          prepend = opts && opts[:prepend] || ''
-          if type == Integer
-            complex_variable(/#{Regexp.quote(prepend)}(\d+)/, proc{|v| Integer(v)}, &blk)
-          else case type
-            when nil
-              complex_variable(/#{Regexp.quote(prepend)}([^\/]+)/, &blk)
-            when Regexp
-              complex_variable(/#{Regexp.quote(prepend)}(#{type.to_s})/, &blk)
-            else
-              raise "Unexpected variable type #{type.inspect}"
-            end
-          end
+        def partial_variable(type = nil, &blk)
+          complex_variable(type, nil, 1, &blk)
         end
         alias_method :part_var, :partial_variable
+        chain_method :partial_variable, :part_var
 
         # Match an extension.
         #
@@ -93,15 +111,16 @@ class Renee
         #   extension('html') { |path| halt [200, {}, path] }
         #
         # @api public
-        def extension(ext)
+        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) { yield } : yield
+                with_path_part(ext_match, &blk) : blk.call
             end
           end
         end
         alias_method :ext, :extension
+        chain_method :extension, :ext
 
         # Match no extension.
         #
@@ -109,9 +128,10 @@ class Renee
         #   no_extension { |path| halt [200, {}, path] }
         #
         # @api public
-        def no_extension
-          yield if detected_extension.nil?
+        def no_extension(&blk)
+          blk.call if detected_extension.nil?
         end
+        chain_method :no_extension
 
         # Match any remaining path.
         #
@@ -119,10 +139,11 @@ class Renee
         #   remainder { |path| halt [200, {}, path] }
         #
         # @api public
-        def remainder
-          with_path_part(env['PATH_INFO']) { |var| yield var }
+        def remainder(&blk)
+          with_path_part(env['PATH_INFO']) { |var| blk.call(var) }
         end
         alias_method :catchall, :remainder
+        chain_method :remainder, :catchall
 
         # Respond to a GET request and yield the block.
         #
@@ -130,9 +151,10 @@ class Renee
         #   get { halt [200, {}, "hello world"] }
         #
         # @api public
-        def get(path = nil)
-          request_method('GET', path) { yield }
+        def get(path = nil, &blk)
+          request_method('GET', path, &blk)
         end
+        chain_method :get
 
         # Respond to a POST request and yield the block.
         #
@@ -140,9 +162,10 @@ class Renee
         #   post { halt [200, {}, "hello world"] }
         #
         # @api public
-        def post(path = nil)
-          request_method('POST', path) { yield }
+        def post(path = nil, &blk)
+          request_method('POST', path, &blk)
         end
+        chain_method :post
 
         # Respond to a PUT request and yield the block.
         #
@@ -150,9 +173,10 @@ class Renee
         #   put { halt [200, {}, "hello world"] }
         #
         # @api public
-        def put(path = nil)
-          request_method('PUT', path) { yield }
+        def put(path = nil, &blk)
+          request_method('PUT', path, &blk)
         end
+        chain_method :put
 
         # Respond to a DELETE request and yield the block.
         #
@@ -160,9 +184,10 @@ class Renee
         #   delete { halt [200, {}, "hello world"] }
         #
         # @api public
-        def delete(path = nil)
-          request_method('DELETE', path) { yield }
+        def delete(path = nil, &blk)
+          request_method('DELETE', path, &blk)
         end
+        chain_method :delete
 
         # Match only when the path has been completely consumed.
         #
@@ -170,20 +195,22 @@ class Renee
         #   delete { halt [200, {}, "hello world"] }
         #
         # @api public
-        def complete
-          with_path_part(env['PATH_INFO']) { yield } if env['PATH_INFO'] == '' || is_index_request
+        def complete(&blk)
+          if env['PATH_INFO'] == '' || is_index_request
+            with_path_part(env['PATH_INFO']) { blk.call }
+          end
         end
+        chain_method :complete
 
         # 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 #=== match each value in the query
-        #   parameters for each key in the hash.
+        #   If given a hash, then every value must be able to be matched by a registered type.
         #
         # @example
-        #   query(:key => 'value') { halt [200, {}, "hello world"] }
+        #   query(:key => :integer) { |h| halt [200, {}, "hello world #{h[:key]}"] }
         #
         # @example
         #   query(:key) { |val| halt [200, {}, "key is #{val}"] }
@@ -191,11 +218,12 @@ class Renee
         # @api public
         def query(q, &blk)
           case q
-          when Hash  then q.any? {|k,v| !(v === request[k.to_s]) } ? return : yield
-          when Array then yield *q.map{|qk| request[qk.to_s] or return }
+          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)
           end
         end
+        chain_method :query
 
         # Yield block if the query string matches.
         #
@@ -211,34 +239,76 @@ class Renee
         #   GET /test?foo=bar #=> 'matched'
         #
         # @api public
-        def query_string(qs)
-          yield if qs === env['QUERY_STRING']
+        def query_string(qs, &blk)
+          blk.call if qs === env['QUERY_STRING']
         end
+        chain_method :query_string
 
         private
-        def complex_variable(matcher = nil, transformer = nil, &blk)
-          warn "variable currently isn't taking any parameters" unless blk.arity > 0
-          if var_value = /^#{(matcher ? matcher.to_s : '\/([^\/]+)') * blk.arity}/.match(env['PATH_INFO'])
-            vars = var_value.to_a
-            with_path_part(vars.shift) { blk.call *vars.map{|v| transformer ? transformer[v[0, v.size]] : v[0, v.size]} }
+        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
+            path.start_with?(prefix) ? path.slice!(0, prefix.size) : break if prefix
+            if match = matcher[path]
+              path.slice!(0, match.first.size)
+              vals << match.last
+            end
+          end
+          return unless count.nil? || count === vals.size
+          with_path_part(env['PATH_INFO'][0, env['PATH_INFO'].size - path.size]) do
+            if count == 1
+              yield(vals.first)
+            else
+              yield(vals)
+            end
+          end
+        end
+
+        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 }
+          end
+        end
+
+        def variable_matcher_for_type(type)
+          if settings.variable_types.key?(type)
+            settings.variable_types[type]
+          else
+            regexp = case type
+            when nil, String
+              detected_extension ?
+                /(([^\/](?!#{Regexp.quote(detected_extension)}$))+)(?=$|\/|\.#{Regexp.quote(detected_extension)})/ :
+                /([^\/]+)(?=$|\/)/
+            when Regexp
+              type
+            else
+              raise "Unexpected variable type #{type.inspect}"
+            end
+            proc do |path|
+              if match = /^#{regexp.to_s}/.match(path)
+                [match[0]]
+              end
+            end
           end
         end
 
         def with_path_part(part)
-          old_path_info = env['PATH_INFO']
-          old_script_name = env['SCRIPT_NAME']
-          old_path_info[part.size, old_path_info.size - part.size]
-          script_part, remaining_part = old_path_info[0, part.size], old_path_info[part.size, old_path_info.size]
+          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]
           env['SCRIPT_NAME'] += script_part
-          env['PATH_INFO'] = remaining_part
           yield script_part
-          env['PATH_INFO'] = old_path_info
-          env['SCRIPT_NAME'] = old_script_name
+          env['PATH_INFO'], env['SCRIPT_NAME'] = old_path_info, old_script_name
         end
 
-        def request_method(method, path = nil)
-          path ? whole_path(path) { yield } : complete { yield } if env['REQUEST_METHOD'] == method
+        def request_method(method, path = nil, &blk)
+          path ? whole_path(path) { blk.call } : complete { blk.call } if env['REQUEST_METHOD'] == method
         end
+        chain_method :request_method
       end
     end
   end

data/lib/renee-core/application/transform.rb

@@ -0,0 +1,13 @@
+class Renee
+  class Core
+    class Application
+      module Transform
+        def transform(type, value)
+          if settings.variable_types.key?(type) and m = settings.variable_types[type][value]
+            m.first == value ? m.last : nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/renee-core/application.rb

@@ -1,7 +1,9 @@
-require File.expand_path(File.dirname(__FILE__) + "/application/request_context")
-require File.expand_path(File.dirname(__FILE__) + "/application/routing")
-require File.expand_path(File.dirname(__FILE__) + "/application/responding")
-require File.expand_path(File.dirname(__FILE__) + "/application/rack_interaction")
+require "renee-core/application/request_context"
+require "renee-core/application/chaining"
+require "renee-core/application/routing"
+require "renee-core/application/responding"
+require "renee-core/application/rack_interaction"
+require "renee-core/application/transform"
 
 class Renee
   class Core
@@ -11,10 +13,12 @@ class Renee
     # It also has methods to interpret arguments to #halt and redirection response helpers.
     # {RackInteraction} adds methods for interacting with Rack.
     class Application
+      include Chaining
       include RequestContext
       include Routing
       include Responding
       include RackInteraction
+      include Transform
 
       attr_reader :application_block, :settings
 

data/lib/renee-core/exceptions.rb

@@ -0,0 +1,11 @@
+class Renee
+  class Core
+    class ClientError < StandardError
+      attr_reader :response
+      def initialize(message, response = nil)
+        super(message)
+        @response = response
+      end
+    end
+  end
+end

data/lib/renee-core/matcher.rb

@@ -0,0 +1,51 @@
+class Renee
+  class Core
+    class Matcher
+      attr_accessor :name
+
+      def initialize(matcher)
+        @matcher = matcher
+      end
+
+      def on_error(&blk)
+        @error_handler = blk
+        self
+      end
+
+      def on_transform(&blk)
+        @transform_handler = blk
+        self
+      end
+
+      def transform(val)
+        val
+      end
+
+      def raise_on_error!(error_code = :bad_request)
+        on_error { halt error_code }
+        self
+      end
+
+      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
+    IntegerMatcher = Matcher.new(/\d+/).on_transform{|v| Integer(v)}
+  end
+end

data/lib/renee-core/settings.rb

@@ -8,9 +8,12 @@ class Renee
     #  Renee::Core.new { ... }.setup { views_path "./views" }
     #
     class Settings
-      attr_reader :includes
+      attr_reader :includes, :variable_types
       def initialize
         @includes = []
+        @variable_types = {}
+        register_variable_type :integer, IntegerMatcher
+        register_variable_type :int, :integer
       end
 
       # Get or sets the views_path for an application.
@@ -29,6 +32,17 @@ class Renee
       def include(mod)
         includes << mod
       end
+
+      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)
+        end
+        matcher.name = name
+        @variable_types[name] = matcher
+      end
     end
   end
 end

data/lib/renee-core/version.rb

@@ -1,6 +1,5 @@
 class Renee
   class Core
-    # The version for the renee-core gem.
-    VERSION = "0.0.1"
+    VERSION = "0.1.0"
   end
 end

data/lib/renee-core.rb

@@ -1,9 +1,11 @@
 require 'rack'
 require 'renee-core/version'
+require 'renee-core/matcher'
 require 'renee-core/settings'
 require 'renee-core/response'
 require 'renee-core/application'
 require 'renee-core/url_generation'
+require 'renee-core/exceptions'
 
 # Renee top-level constant
 class Renee
@@ -51,7 +53,7 @@ class Renee
     #
     # @api public
     def setup(path = nil, &blk)
-      raise "Must be either path or blk to configure settings" if path && blk
+      raise "You cannot supply both an argument and a block to the method." unless path.nil? ^ blk.nil?
       case path
       when nil      then settings.instance_eval(&blk)
       when Settings then @settings = path

data/test/chaining_test.rb

@@ -0,0 +1,33 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Route chaining" do
+
+  it "should chaining" do
+    type = { 'Content-Type' => 'text/plain' }
+    mock_app do
+      path('/').get { halt [200,type,['foo']] }
+      path('bar').put { halt [200,type,['bar']] }
+      path('bar').var.put { |id| halt [200,type,[id]] }
+      path('bar').var.get.halt { |id| "wow, nice to meet you " }
+    end
+    get '/'
+    assert_equal 200,   response.status
+    assert_equal 'foo', response.body
+    put '/bar'
+    assert_equal 200,   response.status
+    assert_equal 'bar', response.body
+    put '/bar/asd'
+    assert_equal 200,   response.status
+    assert_equal 'asd', response.body
+  end
+
+  it "should chain and halt with a non-routing method" do
+    type = { 'Content-Type' => 'text/plain' }
+    mock_app do
+      path('/').get.halt "hi"
+    end
+    get '/'
+    assert_equal 200,   response.status
+    assert_equal 'hi', response.body
+  end
+end

data/test/routing_test.rb

@@ -70,15 +70,16 @@ describe Renee::Core::Application::Routing do
     it "accepts a set of query params (as hash)" do
       mock_app do
         path 'test' do
-          query :foo => "bar" do
-            halt 200
+          query :foo => :integer do |h|
+            halt "foo is #{h[:foo].inspect}"
           end
         end
       end
 
-      get '/test?foo=bar'
+      get '/test?foo=123'
       assert_equal 200, response.status
-      get '/test?foo=bar2'
+      assert_equal 'foo is 123', response.body
+      get '/test?foo=bar'
       assert_equal 404, response.status
     end
 
@@ -140,13 +141,13 @@ describe Renee::Core::Application::Routing do
         end
 
         path 'two' do
-          variable do |foo, bar|
+          var.var do |foo, bar|
             get { halt [200, type,["#{foo}-#{bar}"]] }
           end
         end
 
         path 'multi' do
-          variable do |foo, bar, lol|
+          multi_var(3) do |foo, bar, lol|
             post { halt [200, type,["#{foo}-#{bar}-#{lol}"]] }
           end
         end
@@ -167,13 +168,13 @@ describe Renee::Core::Application::Routing do
       type = { 'Content-Type' => 'text/plain' }
       mock_app do
         path 'test' do
-          var do  |id|
+          var do |id|
             path 'moar' do
               post { halt [200, type, [id]] }
             end
 
             path 'more' do
-              var do |foo, bar|
+              var.var do |foo, bar|
                 get { halt [200, type, ["#{foo}-#{bar}"]] }
 
                 path 'woo' do
@@ -200,7 +201,7 @@ describe Renee::Core::Application::Routing do
       type = { 'Content-Type' => 'text/plain' }
       mock_app do
         path 'add' do
-          variable :type => Integer do |a, b|
+          var(:integer).var(:integer) do |a, b|
             halt [200, type, ["#{a + b}"]]
           end
         end
@@ -211,11 +212,49 @@ describe Renee::Core::Application::Routing do
       assert_equal '7', response.body
     end
 
+    it "allows arbitrary ranges of values" do
+      type = { 'Content-Type' => 'text/plain' }
+      mock_app do
+        path 'add' do
+          multi_var(2..5, :integer).get do |numbers|
+            halt [200, type, ["Add up to #{numbers.inject(numbers.shift) {|m, i| m += i}}"]]
+          end
+        end
+      end
+
+      get '/add/3/4'
+      assert_equal 200, response.status
+      assert_equal 'Add up to 7', response.body
+      get '/add/3/4/6/7'
+      assert_equal 200, response.status
+      assert_equal 'Add up to 20', response.body
+      get '/add/3/4/6/7/8/10/2'
+      assert_equal 404, response.status
+    end
+
+    it "accepts allows repeating vars" do
+      type = { 'Content-Type' => 'text/plain' }
+      mock_app do
+        path 'add' do
+          glob :integer do |numbers|
+            halt [200, type, ["Add up to #{numbers.inject(numbers.shift) {|m, i| m += i}}"]]
+          end
+        end
+      end
+
+      get '/add/3/4'
+      assert_equal 200, response.status
+      assert_equal 'Add up to 7', response.body
+      get '/add/3/4/6/7'
+      assert_equal 200, response.status
+      assert_equal 'Add up to 20', response.body
+    end
+
     it "accepts a regexp" do
       type = { 'Content-Type' => 'text/plain' }
       mock_app do
         path 'add' do
-          variable /foo|bar/ do |a, b|
+          var(/foo|bar/).var(/foo|bar/) do |a, b|
             halt [200, type, ["#{a + b}"]]
           end
         end
@@ -284,6 +323,31 @@ describe Renee::Core::Application::Routing do
       get '/test.xml'
       assert_equal 404,    response.status
     end
+
+    it "should match an extension when there is a non-specific variable before" do
+      mock_app do
+        var do |id|
+          extension 'html' do
+            halt "html #{id}"
+          end
+          extension 'xml' do
+            halt "xml #{id}"
+          end
+          no_extension do
+            halt "none #{id}"
+          end
+        end
+      end
+      get '/var.html'
+      assert_equal 200,        response.status
+      assert_equal 'html var', response.body
+      get '/var.xml'
+      assert_equal 200,        response.status
+      assert_equal 'xml var',  response.body
+      get '/var'
+      assert_equal 200,        response.status
+      assert_equal 'none var',  response.body
+    end
   end
 
   describe "with part and part_var" do
@@ -319,7 +383,7 @@ describe Renee::Core::Application::Routing do
       mock_app do
         part '/test' do
           part 'more' do
-            part_var Integer do |var|
+            part_var :integer do |var|
               path 'test' do
                 halt var.to_s
               end
@@ -389,7 +453,7 @@ describe Renee::Core::Application::Routing do
     it "should match parts and partial vars" do
       mock_app do
         part('test') {
-          part_var(Integer) { |id|
+          part_var(:integer) { |id|
             part('more') {
               halt "the id is #{id}"
             }

data/test/variable_type_test.rb

@@ -0,0 +1,57 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe Renee::Core::Matcher do
+  it "should transform variables" do
+    mock_app {
+      var :symbol do |i|
+        halt i.inspect
+      end
+    }.setup {
+      register_variable_type(:symbol, /[a-z_]+/).on_transform{|v| v.to_sym}
+    }
+    get '/test'
+    assert_equal ":test", response.body
+  end
+
+  it "should halt on errors if told to" do
+    mock_app {
+      var :symbol do |i|
+        halt i.inspect
+      end
+    }.setup {
+      register_variable_type(:symbol, /[a-z_]+/).on_transform{|v| v.to_sym}.raise_on_error!
+    }
+    get '/123'
+    assert_equal 400, response.status
+  end
+
+  it "should allow custom error handling behaviour on values that don't match" do
+    mock_app {
+      var :symbol do |i|
+        halt i.inspect
+      end
+    }.setup {
+      register_variable_type(:symbol, /[a-z_]+/).on_transform{|v| v.to_sym}.on_error{|v| halt 500 }
+    }
+    get '/123'
+    assert_equal 500, response.status
+  end
+
+  it "should allow composite variable types" do
+    mock_app {
+      path("plus10").var(:int_or_hex) do |i|
+        halt "plus10: #{i + 10}"
+      end
+    }.setup {
+      register_variable_type(:int, /[0-9]+/).on_transform{|v| Integer(v)}
+      register_variable_type(:hex, /0x[0-9a-f]+/).on_transform{|v| v.to_i(16)}
+      register_variable_type(:int_or_hex, [:hex, :int])
+    }
+    get '/plus10/123'
+    assert_equal 'plus10: 133', response.body
+    get '/plus10/0x7b'
+    assert_equal 'plus10: 133', response.body
+  end
+end
+
+

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: renee-core
 version: !ruby/object:Gem::Version 
-  hash: 29
   prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 1
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors: 
 - Josh Hull
@@ -17,88 +12,63 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-15 00:00:00 Z
+date: 2011-10-19 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id001 !ruby/object:Gem::Requirement 
+  name: rack
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 27
-        segments: 
-        - 1
-        - 3
-        - 0
         version: 1.3.0
-  requirement: *id001
   type: :runtime
   prerelease: false
-  name: rack
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id002 !ruby/object:Gem::Requirement 
+  name: minitest
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 21
-        segments: 
-        - 2
-        - 6
-        - 1
         version: 2.6.1
-  requirement: *id002
   type: :development
   prerelease: false
-  name: minitest
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id003 !ruby/object:Gem::Requirement 
+  name: bundler
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 1
-        - 0
-        - 10
         version: 1.0.10
-  requirement: *id003
   type: :development
   prerelease: false
-  name: bundler
+  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id004 !ruby/object:Gem::Requirement 
+  name: rack-test
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 11
-        segments: 
-        - 0
-        - 5
-        - 0
         version: 0.5.0
-  requirement: *id004
   type: :development
   prerelease: false
-  name: rack-test
+  version_requirements: *id004
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id005 !ruby/object:Gem::Requirement 
+  name: rake
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - "="
       - !ruby/object:Gem::Version 
-        hash: 49
-        segments: 
-        - 0
-        - 8
-        - 7
         version: 0.8.7
-  requirement: *id005
   type: :development
   prerelease: false
-  name: rake
+  version_requirements: *id005
 description: The super-friendly rack helpers.
 email: 
 - joshbuddy@gmail.com
@@ -111,24 +81,31 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- .yardopts
 - README.md
 - Rakefile
 - ideal.rb
 - lib/renee-core.rb
 - lib/renee-core/application.rb
+- lib/renee-core/application/chaining.rb
 - lib/renee-core/application/rack_interaction.rb
 - lib/renee-core/application/request_context.rb
 - lib/renee-core/application/responding.rb
 - lib/renee-core/application/routing.rb
+- lib/renee-core/application/transform.rb
+- lib/renee-core/exceptions.rb
+- lib/renee-core/matcher.rb
 - lib/renee-core/response.rb
 - lib/renee-core/settings.rb
 - lib/renee-core/url_generation.rb
 - lib/renee-core/version.rb
 - renee-core.gemspec
+- test/chaining_test.rb
 - test/responding_test.rb
 - test/routing_test.rb
 - test/test_helper.rb
 - test/url_generation_test.rb
+- test/variable_type_test.rb
 homepage: ""
 licenses: []
 
@@ -142,7 +119,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: -2644091870970264113
       segments: 
       - 0
       version: "0"
@@ -151,7 +128,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: -2644091870970264113
       segments: 
       - 0
       version: "0"
@@ -163,7 +140,10 @@ signing_key:
 specification_version: 3
 summary: The super-friendly rack helpers.
 test_files: 
+- test/chaining_test.rb
 - test/responding_test.rb
 - test/routing_test.rb
 - test/test_helper.rb
 - test/url_generation_test.rb
+- test/variable_type_test.rb
+has_rdoc: