sansom 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 33777ff470f9889d21b8854b1dea67b731a38a32
-  data.tar.gz: 3c0baa22623738bc1668c91328f057e862c9e1e1
+  metadata.gz: fececc46ad6a785f2e8cc4be0035fff8f7a7d998
+  data.tar.gz: 725f8e1256721a69d085cbec36591a3596483245
 SHA512:
-  metadata.gz: e83bcf72135895c959bc11282caab7780243338afdeddd9e0c7c6e6c1150d8251b01191c4f03666f1d9a7cf66f3a5dca04bcd733d5c8da0e29acf52ef2308299
-  data.tar.gz: 1ba7cf9530ea405f9b7c582b664a4f65b7f18942f1b3077de3b7c00e6df339847b55acf14fd6fb3f4f71bdd596b8c0afadbbcc263dc8a92328cef7a250e50bd6
+  metadata.gz: 9dbbc5555a69229e68474ce0be6e662cd30fe8bffbaee6a3685b061802735deb72eb3e59db65cd3cc69c9df6a11aae794874e3d92596882d09ff3cf0924410f0
+  data.tar.gz: 06c215518e828dd5c0da1b20b6cbaa0dd0d5d80ae374ac60ac24d7d584881e95e4e70b5353082db8675b27d9e0d2b692530513b998d590b3d4d2785322169052

data/README.md

@@ -16,100 +16,88 @@ You can write one `Sansomable` for your entire API.
 
 Fuck it.
 
-***A piece of software should not be a magic box.***
+***A tool should do one thing, and do it well. (Unix philosophy)***
 
-A web framework is, however simplistically, a tool to connect code to a URL's path.
+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, nor change how ruby works to the point where you're not writing Ruby code but instead `Rails` or `Sinatra` code.
+A web framework doesn't provide an ORM, template rendering, shortcuts, nor security patches. 
+
+***A web framework shall remain a framework***
+
+No single tool should get so powerful that it can overcome its master. Rails and Sinatra have been doing this: modifying the language beyond recognition. Rails has activerecord and Sinatra's blocks aren't really blocks.
 
 Installation
 -
 
 `gem install sansom`
 
-Usage
+General Usage
 -
+Traditional approach:
 
-It's pretty simple. Instead of `Class`s storing routes, `Object`s store routes.
-
-There are two ways you can deploy `Sansom`:
+    # config.ru
+    
+    require "sansom"
+    
+    s = Sansom.new
+    # define routes on s
+    run s
+    
+One-file approach:
 
     # app.rb
-    
-    #!/usr/bin/env ruby
 
 	require "sansom"
 
     s = Sansom.new
-    s.get "/" do |r|
-      # r is a Rack::Request
-      [200, { "Content-Type" => "text/plain" }, ["Hello Sansom"]]
-    end
+    # 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, the more production-ready version:
+Writing your own traditional-style webapp
+-
 
-    # config.ru
-    
-    require "sansom"
-    
-    s = Sansom.new
-    
-    s.get "/" do |r|
-      # r is a Rack::Request
-      [200, { "Content-Type" => "text/plain" }, ["Hello Sansom"]]
-    end
-    
-    run s
-    
-But `Sansom` can do more than just that:
+Writing a one-file webapp is as simple as creating a `Sansomable`, defining routes on it, and calling start on it.
 
-It can be used in a similar fashion to Sinatra:
+####There is more footwork for a traditional-style webapp:
 
-    # myapi.rb
-    
-    #!/usr/bin/env ruby
-    
-    require "sansom"
-    
-    class MyAPI < Sansom
-      # This method is used to define Sansom routes
-      def template
-        get "/" do |r|
-          [200, { "Content-Type" => "text/plain" }, ["Hello Sansom"]]
-          # r is a Rack::Request
-        end
-      end
-    end
+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.
+
+	# myapi.rb
+	
+	require "sansom"
+	
+	class MyAPI
+	  include Sansomable
+	  def template
+	  	# define routes here
+	  end
+	end
     
 And your `config.ru` file
 
     # config.ru
     
-    require "sansom"
     require "./myapi"
     
     run MyAPI.new
     
-Sansom can also map other instances of Sansom to a route. Check this:
-    
-    # myapi.rb
-    
-    #!/usr/bin/env ruby
-    
-    require "sansom"
-    
-    class MyAPI < Sansom
-      # This method is used to define Sansom routes
-      def template
-        get "/" do |r|
-          [200, { "Content-Type" => "text/plain" }, ["Hello Sansom"]]
-          # r is a Rack::Request
-        end
-      end
+Defining Routes
+-
+Routes can be defined like so:
+
+    s = Sansom.new
+    s.get "/" do |r| # r is a Rack::Request
+	  [200, {}, ["Return a Rack response."]]
     end
-    
-Let's say you've written a new version of your api. No problem.
+
+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:
     
     # app.rb
     
@@ -120,38 +108,68 @@ Let's say you've written a new version of your api. No problem.
     s.map "/v2", MyNewAPI.new
     s.start
     
-Or maybe you want to mount your Rails/Sinatra/whatever app
+Sansom blocks vs Sinatra blocks
+-
+
+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.
+
+Sinatra blocks 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.
+
+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.
 
     # app.rb
     
     require "sansom"
     
     s = Sansom.new
-    s.map "/api", SinatraApp.new
-    s.map "/", RailsApp.new
-    s.start
+    s.before do |r|
+      next [200, {}, ["Preëmpted."]] if some_condition
+    end
     
-Lastly, any object can become a "`Sansom`" through a mixin:
+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.
 
-    # mixin.ru
+    # app.rb
+    
+    require "sansom"
     
-    class Mixin < Hash
-      include Sansomable
-  
-      def template
-        get "/sansomable" do |r|
-          [200, { "Content-Type" => "text/plain"}, ["Sansomable Hash"]]
-        end
-      end
+    s = Sansom.new
+    s.after do |req,res| # req is a Rack::Request and res is the response generated by a route.
+      next [200, {}, ["Postëmpted."]] if some_condition
     end
+
+Errors
+-
+
+Error blocks allow for the app to return something parseable when an error is raised.
+
+    require "sansom"
+    require "json"
     
-    run Mixin.new
+    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]]
+    end
     
-If you look at how `Sansom` is defined, it makes sense:
+There is also a unique error 404 handler:
 
-    Sansom = Class.new Object
-    Sansom.include Sansomable
+    require "sansom"
+    require "json"
     
+    s = Sansom.new
+    s.not_found do |r| # r is a Rack::Request
+      [404, {"yo" => "shit"}, [{ :message => "not found" }.to_json]]
+    end
+
 Matching
 -
 
@@ -162,7 +180,10 @@ Matching
   	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
-  
+  	
+Some examples of routes Sansom recognizes:  
+	`/path/to/resource` - Standard path  
+	`/users/:id/show` - Parameterized path  
 
 Notes
 -
@@ -177,32 +198,26 @@ Speed
 
 Well, that's great and all, but how fast is "hello world" example in comparision to Rack or Sinatra?
 
-Rack: **15ms**<br />
-Sansom: **15ms**<br />
+Rack: **12ms**<br />
+Sansom: **15ms**\*<br />
 Sinatra: **28ms**<br />
-Rails: **34ms**
+Rails: **34ms****
 
-(results are rounded down)
+(results are measured locally using Puma and are rounded down)
 
 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.
+\** Rails loads a rich welcome page which may contribute to its slowness
+
 Todo
 -
 
-1. Returning more than just rack responses:
-   * Strings
-   * Objects
-   * Maybe more syntactic sugar
-2. (Even) more stability
-3. \<Your idea here\>
+* Multiple return types for routes
+
+If you have any ideas, let me know!
 
 Contributing
 -
 
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create a new Pull Request
-
-**Please 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 is brevity.**

data/changelog.md

@@ -61,4 +61,16 @@ Here's an example
 
 0.1.2
 
-- Fixed issue with `include` in the `Sansom` class
+- Fixed issue with `include` in the `Sansom` class
+
+0.2.0
+
+- Rewrite internals to:
+  1. Avoid collisions with the including class
+  2. Improve performance
+  3. Look better
+  4. **Avoid bugs**
+  
+- Route match caching by path and HTTP method  
+  ->Should improve performance for static paths dramatically
+  

data/lib/rack/fastlint.rb

@@ -3,36 +3,37 @@
 require "rack"
 
 module Rack
-  class Fastlint
-    def self.response res
-      return false unless res.kind_of?(Array) && res.count == 3
+  class Lint
+    def self.fastlint res
+      return false unless res.respond_to?(:to_a) && res.count == 3
       
-      status, headers, body = res
+      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)
       
-      if body.respond_to? :to_path
-        return false unless 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
       
-      begin
-        headers.each { |k,v|
-          next if key =~ /^rack\..+$/
-          throw StandardError unless k.kind_of? String
-          throw StandardError unless v.kind_of? String
-          throw StandardError if k.downcase == "status"
-          throw StandardError unless k !~ /[:\n]/
-          throw StandardError unless k !~ /[-_]\z/
-          throw StandardError 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
       
-        body.each { |part| throw StandardError unless part.kind_of? String }
-      rescue StandardError
-        return false
-      end
-
       true
     end
   end

data/lib/sansom.rb

@@ -1,94 +1,6 @@
 #!/usr/bin/env ruby
 
-require "rack"
-require_relative "./sansom/pine"
-require_relative "./rack/fastlint.rb"
-
-module Sansomable
-  InvalidRouteError = Class.new StandardError
-  HTTP_VERBS = [:get,:head, :post, :put, :delete, :patch, :options, :link, :unlink, :trace].freeze
-  ROUTE_METHODS = HTTP_VERBS+[:map]
-  RACK_HANDLERS = ["puma", "unicorn", "thin", "webrick"].freeze
-  NOT_FOUND = [404, {}, ["Not found."]].freeze
-
-  def tree
-    if @tree.nil?
-      @tree = Pine::Node.new "ROOT"
-      template if respond_to? :template
-    end
-    @tree
-  end
-  
-  def call env
-    return NOT_FOUND if tree.leaf? && tree.root?
-  
-    r = Rack::Request.new env
-    m = tree.match r.path_info, r.request_method
-  
-    return NOT_FOUND if m.nil?
-    
-    begin
-      if @before_block && @before_block.arity == 1
-        bres = @before_block.call r
-        return bres if Rack::Fastlint.response bres
-      end
-
-      if m.url_params.count > 0
-        q = r.params.merge m.url_params
-        s = q.map { |p| p.join '=' }.join '&'
-        r.env["rack.request.query_hash"] = q
-        r.env["rack.request.query_string"] = s
-        r.env["QUERY_STRING"] = s
-        r.instance_variable_set "@params", r.POST.merge(q)
-      end
-    
-      case m.item
-      when Proc then res = m.item.call r
-      else
-        raise InvalidRouteError, "Route handlers must be blocks or valid rack apps." unless m.item.respond_to? :call
-        r.env["PATH_INFO"] = m.remaining_path
-        res = m.item.call r.env
-      end
-    
-      if @after_block && @after_block.arity == 2
-        ares = @after_block.call r, res
-        return ares if Rack::Fastlint.response ares
-      end
-    
-      res
-    rescue StandardError => e
-      b = (@error_blocks[e.class] || @error_blocks[:default]) rescue nil
-      raise e if b.nil?
-      b.call e, r
-    end
-  end
-  
-  def start port=3001
-    raise NoRoutesError if tree.leaf?
-    Rack::Handler.pick(RACK_HANDLERS).run self, :Port => port
-  end
-  
-  def error error_key=:default, &block
-    @error_blocks ||= {}
-    @error_blocks[error_key] = block
-  end
-  
-  def before &block
-    @before_block = block
-  end
-  
-  def after &block
-    @after_block = block
-  end
-  
-  def method_missing meth, *args, &block
-    path, item = *args.dup.push(block)
-    return super unless path && item
-    return super unless item != self
-    return super unless ROUTE_METHODS.include? meth
-    tree.map_path path, item, meth
-  end
-end
+require_relative "./sansom/sansomable"
 
 Sansom = Class.new Object
 Sansom.send :include, Sansomable

data/lib/sansom/pine.rb

@@ -1,108 +1,92 @@
 #!/usr/bin/env ruby
 
-# Path routing tree
+# Tree data structure designed specifically for
+# routing. It is capable of matching both wildcards
+# and semiwildcards.
+# 
+# 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)
 
-module Pine
-  Result = Struct.new :item, :remaining_path, :url_params
+require_relative "./pine/node"
 
-  class Content
-    attr_reader :items, :map
-    
-    def initialize
-      @items = []
-      @map = {}
-    end
-    
-    def set k,v
-      @items << v if k == :map
-      @map[k] = v unless k == :map
-    end
+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
+                     
+  def initialize
+    @root = Pine::Node.new
+    @cache = {}
   end
   
-  class Node
-    attr_reader :name, :parent, :content
-
-    def initialize name
-      @name = name
-      @content = Content.new
-      @children = {}
-    end
+  def empty?
+    @root.leaf?
+  end
   
-    def root?
-      @parent.nil?
-    end
+  # returns all non-root path components
+  # path_comps("/my/path/")
+  # => ["my", "path"]
+  def path_comps path
+    path[1..(path[-1] == "/" ? -2 : -1)].split "/"
+  end
   
-    def leaf?
-      @children.count == 0
+  # map_path "/food", Subsansom.new, :map
+  # map_path "/", my_block, :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
+
+    if key == :map && !handler.is_a?(Proc) # fucking ruby interpreter
+      if handler.singleton_class.include? Sansomable
+        node.subsansoms << handler
+      else
+        node.rack_app = handler
+      end
+    else
+      node.blocks[key] = handler
     end
     
-    def wildcard?
-      @name.start_with? ":"
-    end
+    self
+  end
+  
+  # match "/", :get
+  def match path, verb
+    return nil if empty?
     
-    def [] k
-      return @children[k] if @children.member? k
-      c = @children.values.first
-      return c if (c.wildcard? rescue false)
-    end
+    k = verb.to_s + path.to_s
+    return @cache[k] if @cache.has_key? k
     
-    def << comp
-      child = self[comp]
-      
-      if child.nil?
-        child = self.class.new comp
-        child.instance_variable_set "@parent", self
-        @children.reject!(&:leaf?) if child.wildcard?
-        @children[comp] = child
-      end
+    matched_length = 0
+    matched_params = {}
+    matched_wildcard = false
 
-      child
-    end
-    
-    def parse_path path
-      c = path.split "/"
-      c[0] = '/'
-      c.delete_at(-1) if c[-1].empty?
+    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_wildcard = true
+      end
       c
     end
     
-    def map_path path, item, key
-      parse_path(path).inject(self) { |node, comp| node << comp }.content.set key, item
-      path
-    end
-    
-    def match path, verb
-      matched_comps = []
-      matched_params = {}
-      
-      walk = parse_path(path).inject self do |node, comp|
-        break node if node.leaf?
-        next node[comp] if node.root?
-        
-        c = node[comp]
-        break node if c.nil?
-        matched_comps << comp
-        matched_params[c.name[1..-1]] = comp if c.wildcard?
-        c
-      end
+    return nil if walk.nil?
 
-      return nil if walk.nil?
-      return nil if walk.root?
+    remaining = path[matched_length..-1]
+    match = walk.blocks[verb.downcase.to_sym]
+    match ||= walk.subsansoms.detect { |i| i._pine.match remaining, verb }
+    match ||= walk.rack_app
 
-      c = walk.content
-      subpath = path.sub "/#{matched_comps.join("/")}", ""
-      
-      match = c.map[verb.downcase.to_sym]
-      match ||= c.items.detect { |i| sansom?(i) && i.tree.match(subpath, verb) }
-      match ||= c.items.detect { |i| !sansom?(i) }
-
-      return nil if match.nil?
-      
-      Result.new match, subpath, matched_params
-    end
+    return nil if match.nil?
     
-    def sansom? obj
-      obj.singleton_class.include? Sansomable
-    end
+    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
   end
-end
+end

data/lib/sansom/pine/node.rb

@@ -0,0 +1,187 @@
+#!/usr/bin/env ruby
+
+# represents a node on the routing tree
+
+# No regexes are used once a node is initialized
+
+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   :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
+      @children = {}
+      @wildcard_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 == 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."
+    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
+      another.ancestor? self
+    end
+    
+    def ancestor? another
+      n = self
+      n = n.parent until n == another || n.root?
+      n == another
+    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
+    end
+    
+    def wildcard?
+      !wildcard_range.nil? && wildcard_range.size == 0
+    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
+    
+    # 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
+    end
+    
+    alias_method :[], :child
+    
+    # chainable
+    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
+    end
+    
+    alias_method :<<, :add_child!
+    
+    def _hchildren; @children; end
+    def _hwcchildren; @wildcard_children; end
+
+    # returns new parent so its chainable
+    def _set_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?
+      end
+      
+      # add to new parent's children structure
+      if wildcard?
+        p._hchildren.reject! { |_,c| c.leaf? }
+        p._hwcchildren.reject! { |_,c| c.leaf? }
+      end
+      p._hwcchildren[name] = self
+      
+      @parent = p # set new parent
+    end
+  end
+end

data/lib/sansom/sansomable.rb

@@ -0,0 +1,104 @@
+#!/usr/bin/env ruby
+
+require "rack"
+require_relative "./pine"
+require_relative "../rack/fastlint"
+
+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
+  VALID_VERBS = (HTTP_VERBS+ACTION_VERBS).freeze
+  RACK_HANDLERS = ["puma", "unicorn", "thin", "webrick"].freeze
+  NOTFOUND_TEXT = "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
+    res = [200, {}, [res.to_str]] if res.respond_to? :to_str
+    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?
+    
+    r = Rack::Request.new env
+    
+    begin
+      r.path_info = m.remaining_path unless Proc === m.handler
+      
+      unless m.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.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
+    rescue => e
+      _call_handler @_error_blocks[e.class], e, r rescue raise e
+    end
+  end
+  
+  def start port=3001, handler=""
+    raise RouteError, "No routes." if _pine.empty?
+    begin
+      h = Rack::Handler.get handler.to_s
+    rescue LoadError, NameError
+      h = Rack::Handler.pick(RACK_HANDLERS)
+    ensure
+      h.run self, :Port => port
+    end
+  end
+  
+  def error error_key=nil, &block
+    (@_error_blocks ||= Hash.new { |h| h[:default] })[error_key || :default] = 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 method_missing meth, *args, &block
+    path, item = *args.dup.push(block)
+    return super unless path && item && item != self
+    return super unless VALID_VERBS.include? meth
+    return super unless item.respond_to? :call
+    _pine.map_path path, item, meth
+  end
+end

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.1.2"
+  s.version       = "0.2.0"
   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."

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sansom
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Nathaniel Symer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-28 00:00:00.000000000 Z
+date: 2014-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -55,6 +55,8 @@ files:
 - lib/rack/fastlint.rb
 - lib/sansom.rb
 - lib/sansom/pine.rb
+- lib/sansom/pine/node.rb
+- lib/sansom/sansomable.rb
 - sansom.gemspec
 homepage: http://github.com/fhsjaagshs/sansom
 licenses: