sansom 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fececc46ad6a785f2e8cc4be0035fff8f7a7d998
-  data.tar.gz: 725f8e1256721a69d085cbec36591a3596483245
+  metadata.gz: 7b5864e32e2af6d42813deac99f743aa5f709377
+  data.tar.gz: 8f7778c22852629a41aa2056c957d68fd295e8b5
 SHA512:
-  metadata.gz: 9dbbc5555a69229e68474ce0be6e662cd30fe8bffbaee6a3685b061802735deb72eb3e59db65cd3cc69c9df6a11aae794874e3d92596882d09ff3cf0924410f0
-  data.tar.gz: 06c215518e828dd5c0da1b20b6cbaa0dd0d5d80ae374ac60ac24d7d584881e95e4e70b5353082db8675b27d9e0d2b692530513b998d590b3d4d2785322169052
+  metadata.gz: cb966e9564c909969af9b96aa1e62e7b0eedaf345b573ee25090bf229e654bc0a978f29c0f3b736948261d0f8abf9090d84f11da3958ce83e996318b0ab10e02
+  data.tar.gz: d5fee84cb9b078c953f72a15ad227adb9d05aad20c801aab84640b8921f2cc06f7cd8b40f68ee21eda9cead4481faf901106c62c51fef82f5bd390f085576795

data/.gitignore

@@ -1,3 +1,4 @@
+ext/sansom/pine/Makefile
 *.gem
 *.rbc
 .bundle

data/README.md

@@ -1,26 +1,24 @@
 Sansom
 ===
 
-Scientific, philosophical, abstract web 'picowork' named after Sansom street in Philly, where it was made.
+No-nonsense web 'picowork' named after Sansom street in Philly, near where it was made.
 
 Philosophy
 -
 
-***A piece of software should not limit you to one way of thinking.***
+***A framework should not limit you to one way of thinking.***
 
-You can write a `Sansomable` for each logical unit of your API, but you also don't have to.
+- You can write a `Sansomable` for each logical unit of your API, but you also don't have to.
 
-You can also mount existing Rails/Sinatra/Rack apps in your `Sansomable`. But you also don't have to.
+- You can also mount existing Rails/Sinatra/Rack apps in your `Sansomable`. But you also don't have to.
 
-You can write one `Sansomable` for your entire API.
+- You can write one `Sansomable` for your entire API.
 
 Fuck it.
 
 ***A tool should do one thing, and do it well. (Unix philosophy)***
 
-A web framework is, fundamentally, a tool to connect code to a URL's path.
-
-A web framework doesn't provide an ORM, template rendering, shortcuts, nor security patches. 
+A web framework is, fundamentally, a tool to connect code to a URL's path. Therefore, a web framework doesn't provide an ORM, template rendering, shortcuts, nor security patches. 
 
 ***A web framework shall remain a framework***
 
@@ -31,96 +29,84 @@ Installation
 
 `gem install sansom`
 
-General Usage
--
-Traditional approach:
-
-    # config.ru
-    
-    require "sansom"
-    
-    s = Sansom.new
-    # define routes on s
-    run s
-    
-One-file approach:
-
-    # app.rb
-
-	require "sansom"
-
-    s = Sansom.new
-    # define routes on s
-    s.start
-    
-They're basically the same, except the rack server evaluates config.ru in its own context. The config.ru approach allows for the config to be separated from the application code.
+Or, you can clone this repo and use `gem build sansom.gemspec` to build the gem.
 
-Writing your own traditional-style webapp
+Writing a Sansom app
 -
+Writing a one-file application is trivial with Sansom:
 
-Writing a one-file webapp is as simple as creating a `Sansomable`, defining routes on it, and calling start on it.
-
-####There is more footwork for a traditional-style webapp:
-
-Sansom is defined like this:
-
-    Sansom = Class.new Object
-    Sansom.send :include, Sansomable
-
-So you'll want your app to either `include Sansomable` or be a subclass of `Sansom`, so that a basic declaration looks like this.
+    # config.ru
 
-	# myapi.rb
-	
-	require "sansom"
+    require "sansom"
 	
 	class MyAPI
 	  include Sansomable
-	  def template
+	  def routes
 	  	# define routes here
 	  end
 	end
     
-And your `config.ru` file
-
-    # config.ru
-    
-    require "./myapi"
-    
     run MyAPI.new
     
 Defining Routes
 -
-Routes can be defined like so:
+Routes are defined through (dynamically resolved) instance methods that correspond to HTTP verbs. They take a path and a block. The block must be able to accept (at least) **one** argument.
 
-    s = Sansom.new
+You can either write 
+
+    require "sansom"
+	
+	class MyAPI
+	  include Sansomable
+	  def routes
+	    get "/" do |r|
+	      # r is a Rack::Request object
+	      [200, {}, ["hello world!"]]
+	    end
+	    
+	    post "/form" do |r|
+	      # return a Rack response
+	    end
+	  end
+	end
+
+
+Routes can also be defined like so:
+
+    s = MyAPI.new
     s.get "/" do |r| # r is a Rack::Request
 	  [200, {}, ["Return a Rack response."]]
     end
 
-You can replace `get` with any http verb. Or `map`, if you want to map a subsansom. Let's say you've written a new version of your api. No problem:
+But let's say you have an existing Sinatra/Rails/Sansom (Rack) app. It's simple: mount them. For example, mounting existing applications can be used to easily version an app:
     
-    # app.rb
+    # config.ru
     
     require "sansom"
     
-    s = Sansom.new
-    s.map "/v1", MyAPI.new
-    s.map "/v2", MyNewAPI.new
-    s.start
+    class Versioning
+      include Sansomable
+    end
     
-Sansom blocks vs Sinatra blocks
+    s = Versioning.new
+    s.mount "/v1", MyAPI.new
+    s.mount "/v2", MyNewAPI.new
+    
+    run s
+    
+Sansom routes vs Sinatra routes
 -
 
-Sansom blocks remain blocks: When a route is mapped, the same block you use is called when a route is matched. It's the same object every time.
+**Sansom routes remain true blocks**: When a route is mapped, the same block you use is called when a route is matched. It's the same object every time.
 
-Sinatra blocks become methods behind the scenes. When a route is matched, Sinatra looks up the method and calls it.
+**Sinatra routes become methods behind the scenes**: When a route is matched, Sinatra looks up the method and calls it.
 
-Sinatra's mechanism allows for the use of `return` inside blocks. Sansom doesn't do this, so you must use the `next` directive in the same way you'd use return.
+It's a common idiom in Sinatra to use `return` to terminate execution of a route prematurely (since Sinatra routes aren't blocks). **You must use `next` instead** (you can relplace all instances of `return` with `next`).
 
 Before filters
 -
 
-You can write before filters to try to preëmpt request processing. If the block returns a valid response, the request is preëmpted & it returns that response.
+You can write before filters to try to preëmpt request processing. If the block returns anything (other than nil) **the request is preëmpted**. In that case, the response from the before block is the response for the request.
 
     # app.rb
     
@@ -128,7 +114,7 @@ You can write before filters to try to preëmpt request processing. If the block
     
     s = Sansom.new
     s.before do |r|
-      next [200, {}, ["Preëmpted."]] if some_condition
+      [200, {}, ["Preëmpted."]] if some_condition
     end
     
 You could use this for request statistics, caching, auth, etc.
@@ -136,7 +122,7 @@ You could use this for request statistics, caching, auth, etc.
 After filters
 -
 
-You can also write after filters to tie up the loose ends of a response. If they return a valid response, that response is used instead of the response from a route. After blocks are not called if a before filter was ever called.
+Called after a route is called. If they return a non-nil response, that response is used instead of the response from a route. After filters are not called if a before filter preëmpted route execution. 
 
     # app.rb
     
@@ -156,8 +142,8 @@ Error blocks allow for the app to return something parseable when an error is ra
     require "json"
     
     s = Sansom.new
-    s.error do |err, r| # err is the error, r is a Rack::Request
-      [500, {"yo" => "shit"}, [{ :message => err.message }.to_json]]
+    s.error do |r, err| # err is the error, r is a Rack::Request
+      [500, {"yo" => "headers"}, [{ :message => err.message }.to_json]]
     end
     
 There is also a unique error 404 handler:
@@ -175,31 +161,51 @@ Matching
 
 `Sansom` uses trees to match routes. It follows a certain set of rules:
 
-  - Wildcard routes can't have any siblings
-  - A matching order is enforced:
-  	1. The route matching the path and verb
-  	2. The first Subsansom that matches the route & verb
-  	3. The first mounted non-`Sansom` rack app matching the route
+1. The route matching the path and verb. Routes have a sub-order:
+	1. "Static" paths
+	2. Wildcards (see below)
+		1. Full mappings (kinda a non-compete)
+		2. Partial mappings
+		3. Splats
+  	3. The first Subsansom that matches the route & verb
+  	4. The first mounted non-`Sansom` rack app matching the route
+  	
   	
-Some examples of routes Sansom recognizes:  
-	`/path/to/resource` - Standard path  
-	`/users/:id/show` - Parameterized path  
+Wildcards
+-
+
+Sansom supports multiple wildcards:
+
+`/path/to/:resource/:action` - Full mapping
+`/path/to/resource.<format>` - Partial mapping
+`/path/to/*.json` - Splat
+`/path/to/*.<format>.<compression>` - You can mix them.
+
+Mappings map part of the route (for example `format` above) to the corresponding part of the matched path (for `/resource.<format>` and `/resource.json` yields a mapping of `format`:`json`).
+
+Mappings (full and partial) are available in `Rack::Request#params` **by name**, and splats are available under the key `splats` in `Rack::Request#params`.
+
+*See the Matching section of this readme for wildcard precedence.*
+
 
 Notes
 -
 
 - `Sansom` does not pollute _any_ `Object` methods, including `initialize`
-- `Sansom` is under **250** lines of code at the time of writing. This includes
-	* Rack conformity & the DSL (`sansom.rb`)
-	* Custom tree-based routing (`pine.rb`)
+- No regexes are used in the entire project.
+- Has one dependency: `rack`
+- `Sansom` is under **400** lines of code at the time of writing. This includes
+	* Rack conformity & the DSL (`sansom.rb`) (~90 lines)
+	* Custom tree-based routing (`sanom/pine.rb`) (~150 lines)
+	* libpatternmatch (~150 lines of C++)
 
 Speed
 -
 
 Well, that's great and all, but how fast is "hello world" example in comparision to Rack or Sinatra?
 
-Rack: **12ms**<br />
-Sansom: **15ms**\*<br />
+Rack: **11ms**<br />
+Sansom: **14ms**\*†<br />
 Sinatra: **28ms**<br />
 Rails: **34ms****
 
@@ -207,7 +213,10 @@ Rails: **34ms****
 
 Hey [Konstantine](https://github.com/rkh), *put that in your pipe and smoke it*.
 
-\* Uncached. If a tree lookup is cached, it will be pretty much as fast as Rack.
+\* Uncached. If a tree lookup is cached, it takes the same time as Rack. 
+
+† Sansom's speed (compared to Sinatra) may be because it doesn't load any middleware by default.
+
 \** Rails loads a rich welcome page which may contribute to its slowness
 
 Todo
@@ -220,4 +229,4 @@ If you have any ideas, let me know!
 Contributing
 -
 
-You know the drill. But ** make sure you don't add tons and tons of code. Part of `Sansom`'s beauty is is brevity.**
+You know the drill. But ** make sure you don't add tons and tons of code. Part of `Sansom`'s beauty is its brevity.**

data/ext/sansom/pine/extconf.rb

@@ -0,0 +1,6 @@
+require "mkmf"
+
+$libs += "-lstdc++"
+with_cppflags("-std=c++0x") { true }
+
+create_makefile "sansom/pine/matcher"

data/lib/rack/fastlint.rb

@@ -5,36 +5,39 @@ require "rack"
 module Rack
   class Lint
     def self.fastlint res
-      return false unless res.respond_to?(:to_a) && res.count == 3
-      
-      status, headers, body = res.to_a
-      return false if status.nil?
-      return false if headers.nil?
-      return false if body.nil?
+      begin
+        return false unless res.respond_to?(:to_a) && res.count == 3
+
+        status, headers, body = res.to_a
+        return false if status.nil?
+        return false if headers.nil?
+        return false if body.nil?
 
-      return false unless status.to_i >= 100 || status.to_i == -1
-      return false unless headers.respond_to? :each
-      return false unless body.respond_to? :each
-      return false if body.respond_to?(:to_path) && !File.exist?(body.to_path)
+        return false unless status.to_i >= 100 || status.to_i == -1
+        return false unless headers.respond_to? :each
+        return false unless body.respond_to? :each
+        return false if body.respond_to?(:to_path) && !File.exist?(body.to_path)
       
-      if status.to_i < 200 || [204, 205, 304].include?(status.to_i)
-        return false if headers.member? "Content-Length"
-        return false if headers.member? "Content-Type"
-      end
+        if status.to_i < 200 || [204, 205, 304].include?(status.to_i)
+          return false if headers.member? "Content-Length"
+          return false if headers.member? "Content-Type"
+        end
       
-      headers.each { |k,v|
-        next if k.start_with? "rack."
-        return false unless k.kind_of? String
-        return false unless v.kind_of? String
-        return false if k == "Status"
-        return false unless k !~ /[:\n]/
-        return false unless k !~ /[-_]\z/
-        return false unless k =~ /\A[a-zA-Z][a-zA-Z0-9_-]*\z/
-      }
+        headers.each { |k,v|
+          next if k.start_with? "rack."
+          return false unless k.kind_of? String
+          return false unless v.kind_of? String
+          return false if k == "Status"
+          return false unless k !~ /[:\n]/
+          return false unless k !~ /[-_]\z/
+          return false unless k =~ /\A[a-zA-Z][a-zA-Z0-9_-]*\z/
+        }
     
-      body.each { |p| return false unless p.respond_to? :to_str } # to_str is implemented by classes that act like strigs
-      
-      true
+        body.each { |p| return false unless p.respond_to? :to_str } # to_str is implemented by classes that act like strigs
+        true
+      rescue => e
+        false
+      end
     end
   end
 end

data/lib/sansom/pine/node.rb

@@ -1,102 +1,44 @@
 #!/usr/bin/env ruby
 
-# represents a node on the routing tree
+# represents a node on the routing tree.
+# does not use any regexes. Rather, it uses
+# a custom pattern matching library
 
-# No regexes are used once a node is initialized
+require "sansom/pine/matcher"
 
 class Pine
   class Node
-    LineageError = Class.new StandardError
-    WILDCARD_REGEX = /<(\w*)\b[^>]*>/.freeze
-    URLPATHSAFE_REGEX = /[^a-zA-Z0-9_-]/.freeze
-    ROOT = "/".freeze
-    
     attr_reader   :name # node "payload" data
     attr_accessor :parent # node reference system
-    attr_reader   :wildcard, :wildcard_range # wildcard data
+    attr_reader   :children # hash of non-patterned children
+    attr_reader   :dynamic_children # array of patterned chilren
     attr_reader   :rack_app, :subsansoms, :blocks # mapping
-    attr_reader   :end_seq, :start_seq, :min_length # stored information used to match wildcards
-    attr_reader   :wildcard_delimeter, :semiwildcard_delimeter # delimiter for wildcard syntax
 
-    # Pine::Node.new "asdf", "$", "?" # creates a node with $ as the wildcard delimiter and ? as the semiwildcard delimiter
-    # Pine::Node.new "asdf", "#" # creates a node with # as the wildcard delimiter and the default semiwildcard delimiter
-    # Pine::Node.new "asdf" # creates a node with the default delimiters
-    # Pine::Node.new # creates root node
-    # Delimiters can be any length
-    def initialize name=ROOT, wc_delim=":", swc_delim="<"
-      raise ArgumentError, "Delimiters must not be safe characters in a URL path." if wc_delim.match URLPATHSAFE_REGEX rescue false
-      raise ArgumentError, "Delimiters must not be safe characters in a URL path." if swc_delim.match URLPATHSAFE_REGEX rescue false
-      @name = name.freeze
+    def initialize n='/'
+      @name = n.freeze
+      @matcher = Pine::Matcher.new name
       @children = {}
-      @wildcard_children = {}
+      @dynamic_children = []
       @blocks = {}
       @subsansoms = []
-      @wildcard_delimeter = wc_delim
-      @semiwildcard_delimeter = swc_delim
-      
-      unless root?
-        if @name.start_with? wildcard_delimeter
-          @wildcard_range = Range.new(0, -1).freeze
-          @wildcard = @name[wildcard_delimeter.length..-1].freeze
-          @start_seq = "".freeze
-          @end_seq = "".freeze
-        else
-          r = ['<','>'].include?(semiwildcard_delimeter) ? WILDCARD_REGEX : /#{swc_delim}(\w*)\b[^#{swc_delim}]*#{swc_delim}/
-          m = @name.match r
-          unless m.nil?
-            o = m.offset 1
-            @wildcard_range = Range.new(o.first-1, (-1*(m.string.length-o.last+1))+1).freeze # calc `last` rel to the last char idx
-            @wildcard = @name[wildcard_range.first+semiwildcard_delimeter.length..wildcard_range.last-semiwildcard_delimeter.length].freeze
-            @start_seq = @name[0..wildcard_range.first-1].freeze
-            @end_seq = wildcard_range.last == -1 ? "" : @name[wildcard_range.last+1..-1].freeze
-          end
-        end
-      end
-      
-      @min_length = dynamic? ? start_seq.length + end_seq.length : name.length
     end
     
-    def inspect
-      "#<#{self.class}: #{name.inspect}, #{dynamic? ? "Wildcard: '" + wildcard + "' #{wildcard_range.inspect}, " : "" }#{@children.count} children, #{leaf? ? "leaf" : "internal node"}>"
-    end
+    def inspect; "#<#{self.class}: #{children.count+dynamic_children.count} children, #{leaf? ? "leaf" : "internal node"}>"; end
     
     def == another
       parent == another.parent &&
       name == another.name
     end
-    
-    # TODO: check correctness of return values
+
     def <=> another
-      return 0 if n == another
-      
-      n = self
-      n = n.parent until n == another || n.root?
-      return 1 if n == another
-      
-      n = another
-      n = n.parent until n == self || n.root?
-      return -1 if n == self
-      
-      raise LinneageError, "Node not in tree."
+      return nil unless another.is_a? Pine::Node
+      return 0 if self == another
+      return -1 if another.ancestor? self
+      return 1 if another.child? self
+      nil
     end
     
-    def detach!
-      _set_parent nil
-    end
-    
-    def siblings
-      parent.children.dup - self
-    end
-    
-    def children
-      hash_children.values
-    end
-    
-    def hash_children
-      Hash[@children.to_a + @wildcard_children.to_a]
-    end
-    
-    def child? another
+    def child? anothrer
       another.ancestor? self
     end
     
@@ -107,46 +49,25 @@ class Pine
     end
     
     def ancestors
-      n = self
-      n = n.parent until n.root?
-      n
-    end
-    
-    def root?
-      name == ROOT
-    end
-   
-    def leaf?
-      children.empty? && subsansoms.empty? && rack_app.nil?
-    end
-    
-    def semiwildcard?
-      !wildcard_range.nil? && wildcard_range.size != 0
+      a = [self]
+      a << a.last.parent until a.last.root?
+      a[1..-1]
     end
     
-    def wildcard?
-      !wildcard_range.nil? && wildcard_range.size == 0
-    end
+    def root?; name == '/'; end
+    def leaf?; children.empty? && dynamic_children.empty? && subsansoms.empty? && rack_app.nil?; end
     
-    # returns true if self is either a wildcard or a semiwildcard
-    def dynamic?
-      !wildcard_range.nil?
-    end
-    
-    # Bottleneck for wildcard-heavy apps
-    def matches? comp
-      return comp == name unless dynamic?
-      comp.length >= min_length && comp.start_with?(start_seq) && comp.end_with?(end_seq)
-    end
+    def dynamic?; @matcher.dynamic? || name.start_with?(':'); end
+    def splats comp; @matcher.splats comp; end
+    def mappings comp; @matcher.mappings comp; end
     
     # WARNING: Sansom's biggest bottleneck
     # Partially chainable: No guarantee the returned value responds to :child or :[]
     def child comp
       raise ArgumentError, "Invalid path component." if comp.nil? || comp.empty?
-      case
-      when @children.empty? && @wildcard_children.empty? then nil
-      when @children.member?(comp) then @children[comp]
-      else @wildcard_children.values.detect { |c| c.matches? comp } end
+      res   = @children[comp]
+      res ||= dynamic_children.detect { |c| c.instance_variable_get("@matcher").matches? comp }
+      res
     end
     
     alias_method :[], :child
@@ -155,32 +76,29 @@ class Pine
     def add_child! comp
       raise ArgumentError, "Invalid path component." if comp.nil? || comp.empty?
       c = self[comp] || self.class.new(comp)
-      c._set_parent self
+      c.parent = self
       c
     end
     
     alias_method :<<, :add_child!
     
-    def _hchildren; @children; end
-    def _hwcchildren; @wildcard_children; end
-
-    # returns new parent so its chainable
-    def _set_parent p
+    def parent= p
       return if @parent == p
       
       # remove from old parent's children structure
       unless @parent.nil?
-        @parent._hchildren.delete name unless dynamic?
-        @parent._hwcchildren.delete name if dynamic?
+        @parent.children.delete name
+        @parent.dynamic_children.reject! { |c| c.name == name }
       end
       
-      # add to new parent's children structure
-      if wildcard?
-        p._hchildren.reject! { |_,c| c.leaf? }
-        p._hwcchildren.reject! { |_,c| c.leaf? }
+      unless p.nil?
+        if dynamic?
+          p.dynamic_children << self # add to new parent's children structure
+        else
+          p.children[name] = self
+        end
       end
-      p._hwcchildren[name] = self
-      
+
       @parent = p # set new parent
     end
   end

data/lib/sansom/pine.rb

@@ -1,22 +1,17 @@
 #!/usr/bin/env ruby
 
 # Tree data structure designed specifically for
-# routing. It is capable of matching both wildcards
-# and semiwildcards.
+# routing. It uses libpatternmatch (google it) to
+# match paths with splats and mappings 
 # 
 # While other path routing software optimizes path parsing,
-# Pine optimizes lookup. You could say it matches a route in
-# something resembling logarithmic time, but really is linear time
-# due to child lookups (children are just iterated over)
+# Pine optimizes lookup and pattern matching. Pine takes
+# logarithmic time in path matching and linear time in 
+# path matching (libpatternmatch)
 
 require_relative "./pine/node"
 
-class Pine
-  Match = Struct.new :handler, # Proc/Subsansom/Rack App
-                     :remaining_path, # Part of path that wasn't matched, applies to subsansoms
-                     :matched_path, # The matched part of a path
-                     :params # Wildcard params
-                     
+class Pine         
   def initialize
     @root = Pine::Node.new
     @cache = {}
@@ -30,18 +25,18 @@ class Pine
   # path_comps("/my/path/")
   # => ["my", "path"]
   def path_comps path
-    path[1..(path[-1] == "/" ? -2 : -1)].split "/"
+    path.nil? || path.empty? ? [] : path[1..(path[-1] == "/" ? -2 : -1)].split('/')
   end
   
   # map_path "/food", Subsansom.new, :map
-  # map_path "/", my_block, :get
+  # map_path "/", ObjectThatRespondsToCall.new, :get
   # it's also chainable
   def map_path path, handler, key
     @cache.clear
 
-    node = (path == "/") ? @root : path_comps(path).inject(@root) { |n, comp| n << comp } # Fucking ruby interpreter
+    node = (path == "/") ? @root : path_comps(path).inject(@root) { |n, comp| n << comp }
 
-    if key == :map && !handler.is_a?(Proc) # fucking ruby interpreter
+    if key == :mount && !handler.is_a?(Proc)
       if handler.singleton_class.include? Sansomable
         node.subsansoms << handler
       else
@@ -62,15 +57,17 @@ class Pine
     return @cache[k] if @cache.has_key? k
     
     matched_length = 0
-    matched_params = {}
+    matched_params = { :splat => [] }
     matched_wildcard = false
 
+    # find a matching node
     walk = path_comps(path).inject @root do |n, comp|
       c = n[comp]
       break n if c.nil?
       matched_length += comp.length+1
       if c.dynamic?
-        matched_params[c.wildcard] = comp[c.wildcard_range] 
+        matched_params.merge! c.mappings(comp)
+        matched_params[:splat].push *c.splats(comp)
         matched_wildcard = true
       end
       c
@@ -78,15 +75,15 @@ class Pine
     
     return nil if walk.nil?
 
-    remaining = path[matched_length..-1]
+    remaining_path = path[matched_length..-1]
     match = walk.blocks[verb.downcase.to_sym]
-    match ||= walk.subsansoms.detect { |i| i._pine.match remaining, verb }
+    match ||= walk.subsansoms.detect { |i| i._pine.match remaining_path, verb }
     match ||= walk.rack_app
 
     return nil if match.nil?
     
-    r = Match.new match, remaining, path[0..matched_length-1], matched_params
-    @cache[k] = r unless matched_wildcard # Only cache static lookups, avoid huge memory usage
+    r = [match, remaining_path, path[0..matched_length-1], matched_params]
+    @cache[k] = r unless matched_wildcard # Only cache static lookups (avoid huge memory usage)
     r
   end
 end

data/lib/sansom/sansomable.rb

@@ -8,24 +8,20 @@ module Sansomable
   RouteError = Class.new StandardError
   ResponseError = Class.new StandardError
   HTTP_VERBS = [:get,:head, :post, :put, :delete, :patch, :options, :link, :unlink, :trace].freeze
-  ACTION_VERBS = [:map].freeze
+  ACTION_VERBS = [:mount].freeze
   VALID_VERBS = (HTTP_VERBS+ACTION_VERBS).freeze
   RACK_HANDLERS = ["puma", "unicorn", "thin", "webrick"].freeze
-  NOTFOUND_TEXT = "Not found.".freeze
+  NOT_FOUND_RESP = [404, {}, ["Not found."]].freeze
 
   def _pine
     if @_pine.nil?
       @_pine = Pine.new
-      template if respond_to? :template
       routes if respond_to? :routes
     end
     @_pine
   end
   
   def _call_handler handler, *args
-    raise ArgumentError, "Handler must not be nil." if handler.nil?
-    raise ArgumentError, "Handler must be a valid rack app." unless handler.respond_to? :call
-    raise ArgumentError, "Handler cannot take all passed args." if handler.respond_to?(:arity) && args.count != handler.arity
     res = handler.call *args
     res = res.finish if res.is_a? Rack::Response
     raise ResponseError, "Response must either be a rack response, string, or object" unless Rack::Lint.fastlint res # custom method
@@ -33,31 +29,28 @@ module Sansomable
     res
   end
   
-  def _not_found
-    return _call_route @_not_found, r unless @_not_found.nil?
-    [404, {}, [NOTFOUND_TEXT]]
-  end
-  
   def call env
-    return _not_found if _pine.empty? # no routes
-    m = _pine.match env["PATH_INFO"], env["REQUEST_METHOD"]
-    return _not_found if m.nil?
+    raise RouteError, "No routes." if _pine.empty?
+    
+    handler, remaining_path, _, route_params = _pine.match env["PATH_INFO"], env["REQUEST_METHOD"]
+    return NOT_FOUND_RESP if handler.nil?
     
     r = Rack::Request.new env
     
     begin
-      r.path_info = m.remaining_path unless Proc === m.handler
+      r.path_info = remaining_path unless Proc === handler
       
-      unless m.params.empty?
+      unless route_params.empty?
         r.env["rack.request.query_string"] = r.query_string # now Rack::Request#GET will return r.env["rack.request.query_hash"]
-        (r.env["rack.request.query_hash"] ||= {}).merge! m.params # update the necessary field in the hash
+        r.env["rack.request.query_hash"] = Rack::Utils.parse_nested_query(r.query_string).merge(route_params) # add route params r.env["rack.request.query_hash"]
         r.instance_variable_set "@params", nil # tell Rack::Request to recalc Rack::Request#params
       end
       
-      res = _call_handler @_before, r if @_before # call before block
-      res ||= _call_handler m.handler, (Proc === m.handler ? r : r.env) # call route handler block
-      res ||= _call_handler @_after, r, res if @_after # call after block
-      res ||= _not_found
+      res   = _call_handler    @_before, r                               if @_before       # call before block
+      res ||= _call_handler     handler, (Proc === handler ? r : r.env)                    # call route handler block
+      res ||= _call_handler     @_after, r, res                          if @_after && res # call after block
+      res ||= _call_handler @_not_found, r                               if @_not_found    # call error block
+      res ||= NOT_FOUND_RESP # fallback error message
       res
     rescue => e
       _call_handler @_error_blocks[e.class], e, r rescue raise e
@@ -75,24 +68,14 @@ module Sansomable
     end
   end
   
-  def error error_key=nil, &block
-    (@_error_blocks ||= Hash.new { |h| h[:default] })[error_key || :default] = block
+  def error error_class=:default, &block
+    raise ArgumentError, "Invalid error: #{error_class}" unless Class === error_class || error_class == :default
+    (@_error_blocks ||= Hash.new { |h| h[:default] })[error_class] = block
   end
   
-  def before &block
-    raise ArgumentError, "Before filter blocks must take one argument." if block && block.arity != 1
-    @_before = block
-  end
-  
-  def after &block
-    raise ArgumentError, "After filter blocks must take two arguments." if block && block.arity != 2
-    @_after = block
-  end
-  
-  def not_found &block
-    raise ArgumentError, "Not found blocks must take one argument." if block && block.arity != 1
-    @_not_found = block
-  end
+  def before █ @_before = block; end # 1 arg
+  def after █ @_after = block; end # 2 args
+  def not_found █ @_not_found = block; end # 1 arg
   
   def method_missing meth, *args, &block
     path, item = *args.dup.push(block)

data/lib/sansom.rb

@@ -1,6 +1,3 @@
 #!/usr/bin/env ruby
 
 require_relative "./sansom/sansomable"
-
-Sansom = Class.new Object
-Sansom.send :include, Sansomable

data/sansom.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |s|
   s.name          = "sansom"
-  s.version       = "0.2.0"
+  s.version       = "0.3.1"
   s.authors       = ["Nathaniel Symer"]
   s.email         = ["nate@natesymer.com"]
   s.summary       = "Scientific, philosophical, abstract web 'picowork' named after Sansom street in Philly, near where it was made."
@@ -14,6 +14,7 @@ Gem::Specification.new do |s|
 
   allfiles = `git ls-files -z`.split("\x0")
   s.files         = allfiles.grep(%r{(^[^\/]*$|^lib\/)}) # Match all lib files AND files in the root
+  s.extensions    = ["ext/sansom/pine/extconf.rb"]
   s.executables   = allfiles.grep(%r{^bin/}) { |f| File.basename(f) }
   s.test_files    = allfiles.grep(%r{^(test|spec|features)/})
   s.require_paths = ["lib"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sansom
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Nathaniel Symer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-30 00:00:00.000000000 Z
+date: 2015-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -44,7 +44,8 @@ description: Scientific, philosophical, abstract web 'picowork' named after Sans
 email:
 - nate@natesymer.com
 executables: []
-extensions: []
+extensions:
+- ext/sansom/pine/extconf.rb
 extra_rdoc_files: []
 files:
 - ".gitignore"
@@ -52,6 +53,7 @@ files:
 - LICENSE.txt
 - README.md
 - changelog.md
+- ext/sansom/pine/extconf.rb
 - lib/rack/fastlint.rb
 - lib/sansom.rb
 - lib/sansom/pine.rb
@@ -78,7 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Scientific, philosophical, abstract web 'picowork' named after Sansom street