sansom 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c81abee4ed6b93558cbc51b117135cf674fde459
-  data.tar.gz: 1bbfd96b4165afe38158c02ac0c0f8cbef6fa0da
+  metadata.gz: 6ea8ea9f12513294f151757423264d44870d210f
+  data.tar.gz: 405f6c890367eaa2c961cc4520f58b1bdc7ddc6d
 SHA512:
-  metadata.gz: 52adf8b2ff6fcfa0ebc4e84647a5f3a912c02c47b50363dfd434eecf60f439ce1e32eec5f773b43b4333b7ece92c26824997283d8b62c113af99620cdd735ba0
-  data.tar.gz: cc53ff5b59f6da3fb832133ec986131621e524ced4fc5e2971f7644c8036ccbac809db0f7557c5cb411cb2238e31309f123ff113804fa0e0a362a1cbecb56ab9
+  metadata.gz: f773bca14fef8bdfb91ba0147d97d952fc72189bd4c8d368e76c5920cf7d9c57c4073fdbd216e97c560f58c1e86481ca9737898d6090fb1246096a01e3e87532
+  data.tar.gz: da9038bc8791abbbf2aed558613d3b922e6dd95eb8feea4cc7e2d09e668536c565e0bd6b5d8fecfcc00907adfd0c0bb1c7b2bc7302152fdccd837831d0c33097

data/README.md

@@ -1,22 +1,23 @@
 Sansom
 ===
 
-Flexible, versatile, light web framework named after Sansom street in Philly.
+Scientific, philosophical, abstract web 'picowork' named after Sansom street in Philly, where it was made.
 
-Installation
+Philosophy
 -
 
-Add this line to your application's Gemfile:
+*A piece of software should not limit you to one way of thinking.*
 
-    gem '.'
+You can write a `Sansomable` for each logical unit of your API, but you also don't have to.
 
-And then execute:
+You can also mount existing Rails/Sinatra apps in your `Sansomable`. But you also don't have to.
 
-    $ bundle
+You can write one `Sansomable` for your entire API.
 
-Or install it yourself as:
+Installation
+-
 
-    $ gem install .
+`gem install sansom`
 
 Usage
 -
@@ -148,18 +149,20 @@ 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
+  
 
 Notes
 -
 
 - `Sansom` does not pollute _any_ `Object` methods, including `initialize`
-- `Sansom` is under **140** lines of code at the time of writing. This includes
-	* Everything above
-	* Custom routing
+- `Sansom` is under **190** lines of code at the time of writing. This includes
+	* Rack conformity & the DSL (`sansom.rb`)
+	* Custom tree-based routing (`pine.rb`)
 
 Contributing
 -

data/changelog.md

@@ -31,4 +31,10 @@ Here's an example
 
 0.0.4
 
-- Fixed bug with with requiring pine
+- Fixed bug with with requiring pine
+
+0.0.5
+
+- Parameterized URLs!!! (Stuff like `/user/:id/profile`)
+	* Parameterized URLs work with mounted Rack/Sansom apps
+- Improved matching efficiency

data/lib/sansom/pine.rb

@@ -2,115 +2,116 @@
 
 # Path routing tree
 
-# Custom tree implementation for path routing
-
-# Custom features:
-# 1. Trimming: Limit a node to a single element
-
 module Pine
   class Node
-    attr_reader :name
+    attr_reader :name, :parent
     attr_accessor :content
-    attr_accessor :parent
   
     def initialize name, content=Content.new
       @name = name
       @content = content
       @children = {}
       @parent = nil
-      @trimmed = false
     end
   
-    # returns a node for chaining
-    def <<(node)
-      if trimmed?
-        # Add to first child
-        children.first << node
-      else
-        node.parent = self
-        @children[node.name] = node
-        node
-      end
-    end
-    
-    def create_if_necessary name
-      unless @children.keys.include? name
-        child = self.class.new name
-        child.parent = self
-        @children[name] = child
-      end
-      @children[name]
+    def root?
+      @parent.nil?
     end
   
-    def root
-      n = self
-      n = n.parent while !n.root?
-      n
+    def leaf?
+      @children.count == 0
     end
     
-    def children
-      @children.values
+    def wildcard?
+      @wildcard
     end
     
-    def trim(node)
-      @trimmed = true
-      @children.clear
-      @children[node.name] = node
-      self
+    def [] k
+      return @children[k] || @children.values.first
+    #  child = @children[k] || @child.values.first
+     # return child unless child.nil?
+      
+     # @children[k] || @children.values.first.wildcard? ? @children.values.first : nil
     end
     
-    def []=(k,v)
-      self << Node.new(k, v)
+    def create_and_save comp
+      child = self.class.new comp
+      child.instance_variable_set "@parent", self
+      @children[comp] = child
+      child
     end
-  
-    def [](k)
-      @children[k]
-    end
-  
-    def root?
-      @parent.nil?
+    
+    def << comp      
+      if comp.start_with? ":"
+        @wildcard = true
+        @children.clear
+        create_and_save comp
+      else
+        child = @children[comp]
+        child = create_and_save comp if !child || (!child && child.leaf? && !child.wildcard?)
+        child
+      end
     end
-  
-    def leaf?
-      @children.count == 0
+
+    def parse_path path
+      c = path.split "/"
+      c[0] = '/'
+      c.delete_at(-1) if c[-1].empty?
+      c
     end
     
-    def trimmed?
-      @trimmed
+    def map_path path, item, key
+      parse_path(path).inject(self) { |node, comp| node << comp }.content[key] = item
+      path
     end
     
-    def inspect(level=0)
-      if root?
-        print "*"
-      else
-        print "|" unless parent.parent.children.last == parent rescue false
-        print(' ' * level * 4)
-        print(parent.children.last == self ? "+" : "|")
-        print "---"
-        print(leaf? ? ">" : "+")
+    def match path, verb
+      matched_comps = []
+      matched_params = {}
+      
+      walk = parse_path(path).inject self do |node, comp|
+        break node if node.leaf?
+        matched_comps << comp unless comp == "/"
+        child = node[comp]
+        matched_params[child.name[1..-1]] = comp if node.wildcard?
+        child
       end
 
-      puts " #{name} #{content.map rescue "fuck"}" 
+      return nil if walk.root? rescue true
+
+      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) }
 
-      children.each { |child| child.inspect(level + 1) if child } # Child might be 'nil'
+      return nil if match.nil?
+      
+      Result.new match, subpath, matched_params
+    end
+    
+    def sansom? obj
+      obj.singleton_class.include? Sansomable
     end
   end
   
+  Result = Struct.new :item, :remaining_path, :url_params
+
   class Content
-    attr_accessor :items
-    attr_accessor :map
+    attr_accessor :items, :map
     
     def initialize
       @items = []
       @map = {}
     end
 
-    def []=(k,v)
+    def []= k,v
       @items << v if k == :map
       @map[k] = v unless k == :map
     end
   
-    def [](k)
+    def [] k
       @items[k] if Numeric === k
       @map[k] unless Numeric === k
     end

data/lib/sansom.rb

@@ -1,109 +1,70 @@
 #!/usr/bin/env ruby
 
 require "rack"
-require "sansom/pine"
+require_relative "./sansom/pine"
 
 module Sansomable
   InvalidRouteError = Class.new StandardError
-  
   HTTP_VERBS = [:get,:head, :post, :put, :delete, :patch, :options].freeze
   HANDLERS = ["puma", "unicorn", "thin", "webrick"].freeze
-  NOT_FOUND = [404, {"Content-Type" => "text/plain"}, ["Not found."]].freeze
-
+  NOT_FOUND = [404, {}, ["Not found."]].freeze
+  
   def tree
-    @tree ||= nil
     if @tree.nil?
-      @tree = Pine::Node.new("ROOT", nil)
+      @tree = Pine::Node.new "ROOT"
       template if respond_to? :template
     end
     @tree
   end
   
-  def before_block
-    @before_block ||= nil
-  end
-
-  def match verb, path
-    components = s_parse_path(path)
-    matched_components = []
-    matched_parameters = {}
-    
-    walk = components.inject(tree) do |node, component|
-      if node.leaf?
-        node
-      else
-        matched_components << component unless component == "/"
-        node[component]
-      end
-    end
-    
-    return nil if walk.root?
-
-    c = walk.content
-    matched_path = "/" + matched_components.join("/")
-
-    match = c[verb.downcase.to_sym] # Check for route
-    match ||= c.items.select(&method(:sansom?)).reject { |item| item.match(verb, path.sub(matched_path, "")).nil? }.first rescue nil # Check subsansoms
-    match ||= c.items.reject(&method(:sansom?)).first rescue nil # Check for mounted rack apps
-    [match, matched_path]
-  end
-  
   def call env
     return NOT_FOUND if tree.leaf?
     
-    r = Rack::Request.new env
+    r = Rack::Request.new env.dup
+    
+    if @before_block
+      res = @before_block.call r
+      return res if [Fixnum, Hash, Array]-res.map(&:class) == 0
+    end
 
-    m = match r.request_method, r.path_info
-    item = m.first
+    m = tree.match r.path_info, r.request_method
     
-    if item.nil?
+    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
+
+    if !m
       NOT_FOUND
+    elsif m.item.is_a? Proc
+      m.item.call r
+    elsif m.item.respond_to? :call
+      r.env["PATH_INFO"] = m.remaining_path
+      m.item.call r.env
     else
-      if before_block
-        res = before_block.call r
-        return res if res[0].is_a?(Numeric) && res[1].is_a?(Hash) && res[2].respond_to?(:each) rescue false
-      end
-      
-      if item.is_a? Proc
-        item.call r
-      elsif sansom? item
-        r.path_info.sub! m[1], ""
-        item.call(r.env)
-      else
-        raise InvalidRouteError, "Invalid route handler, it must be a block (proc/lambda) or a subclass of Sansom."
-      end
+      raise InvalidRouteError, "Route handlers must be blocks or valid rack apps."
     end
   end
   
   def start port=3001
-    raise NoRoutesError if tree.children.empty?
+    raise NoRoutesError if tree.leaf?
     Rack::Handler.pick(HANDLERS).run self, :Port => port
   end
   
-  def before(&block)
+  def before &block
     @before_block = block
   end
   
-  def method_missing(meth, *args, &block)
+  def method_missing meth, *args, &block
     path, item = *args.dup.push(block)
     return super unless path && item
-    return super if item == self
-    return super unless HTTP_VERBS.include?(meth) || meth == :map
-    
-    n = s_parse_path(path).inject(tree) { |node, comp| node.create_if_necessary comp }
-    n.content[meth] = item
-  end
-  
-  private
-  
-  def sansom? obj
-    return true if obj.is_a? Sansom
-    return true if obj.class.included_modules.include? Sansomable
-    false
-  end
-
-  def s_parse_path path
-    path.split("/").reject(&:empty?).unshift("/")
+    return super unless item != self
+    return super unless (HTTP_VERBS+[:map]).include?(meth)
+    tree.map_path path, item, meth
   end
 end
 

data/sansom.gemspec

@@ -4,17 +4,18 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |s|
   s.name          = "sansom"
-  s.version       = "0.0.4"
+  s.version       = "0.0.5"
   s.authors       = ["Nathaniel Symer"]
   s.email         = ["nate@natesymer.com"]
-  s.summary       = "Flexible, versatile, light web framework named after Sansom street in Philly."
-  s.description   = s.summary + "It's under 140 lines of code & and it's lightning fast. It uses tree-based route resolution."
+  s.summary       = "Scientific, philosophical, abstract web 'picowork' named after Sansom street in Philly, near where it was made."
+  s.description   = s.summary + " " + "It's under 200 lines of code & it's lightning fast. It uses tree-based route resolution."
   s.homepage      = "http://github.com/fhsjaagshs/sansom"
   s.license       = "MIT"
 
-  s.files         = `git ls-files -z`.split("\x0")
-  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  allfiles = `git ls-files -z`.split("\x0")
+  s.files         = allfiles.grep(%r{(^[^\/]*$|^lib\/)}) # Match all lib files AND files in the root
+  s.executables   = allfiles.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = allfiles.grep(%r{^(test|spec|features)/})
   s.require_paths = ["lib"]
 
   s.add_development_dependency "bundler", "~> 1.6"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sansom
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Nathaniel Symer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-30 00:00:00.000000000 Z
+date: 2014-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,9 +38,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
-description: Flexible, versatile, light web framework named after Sansom street in
-  Philly.It's under 140 lines of code & and it's lightning fast. It uses tree-based
-  route resolution.
+description: Scientific, philosophical, abstract web 'picowork' named after Sansom
+  street in Philly, near where it was made. It's under 200 lines of code & it's lightning
+  fast. It uses tree-based route resolution.
 email:
 - nate@natesymer.com
 executables: []
@@ -52,9 +52,6 @@ files:
 - LICENSE.txt
 - README.md
 - changelog.md
-- examples/before.rb
-- examples/generic.rb
-- examples/mixin.rb
 - lib/sansom.rb
 - lib/sansom/pine.rb
 - sansom.gemspec
@@ -81,5 +78,6 @@ rubyforge_project:
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Flexible, versatile, light web framework named after Sansom street in Philly.
+summary: Scientific, philosophical, abstract web 'picowork' named after Sansom street
+  in Philly, near where it was made.
 test_files: []

data/examples/before.rb

@@ -1,20 +0,0 @@
-#!/usr/bin/env ruby
-
-require_relative "../lib/sansom" rescue require "sansom"
-
-s = Sansom.new
-
-s.before do |r|
-  puts "(#{s.class.to_s}) #{r.request_method.upcase} #{r.path_info}"
-  [200, {}, ["Hijacked by before!"]] if Random.new.rand(2) == 1
-end
-
-s.get "/" do |r|
-  [200, { "Content-Type" => "text/plain"}, ["root"]]
-end
-
-s.get "/something" do |r|
-  [200, { "Content-Type" => "text/plain" }, ["something"]]
-end
-
-s.start 2000

data/examples/generic.rb

@@ -1,79 +0,0 @@
-#!/usr/bin/env ruby
-
-require "json"
-require_relative "../lib/sansom" rescue require "sansom"
-
-class Sansom
-  def food_response r
-    [200, { "Content-Type" => "text/plain"}, [{ :type => self.class.to_s, :name => r.path_info.split("/").reject(&:empty?).last}.to_json]]
-  end
-end
-
-class Meat < Sansom
-  def template
-    get "/pork" do |r|
-      food_response r
-    end
-  end
-end
-
-class NonAnimal < Sansom
-  def template
-    get "/quinoa" do |r|
-      food_response r
-    end
-    
-    get "/tahini" do |r|
-      food_response r
-    end
-    
-    get "/squash" do |r|
-      food_response r
-    end
-  end
-end
-
-class AnimalProducts < Sansom
-  def template
-    get "/eggs" do |r|
-      food_response r
-    end
-  
-    get "/milk" do |r|
-      food_response r
-    end
-  end
-end
-
-class FoodTypes < Sansom
-  def template
-    map "/carnivorous", Meat.new
-    map "/vegetarian", NonAnimal.new
-    map "/vegetarian", AnimalProducts.new
-    map "/vegan", NonAnimal.new
-  end
-end
-
-class Food < Sansom
-  def template
-    get "/sushi" do |r|
-      [200, { "Content-Type" => "text/plain"}, ["Quite delicious, especially cucumber"]]
-    end
-    
-    map "/types", FoodTypes.new
-  end
-end
-
-s = Sansom.new
-
-s.get "/" do |r|
-  [200, { "Content-Type" => "text/plain"}, ["root"]]
-end
-
-s.get "/something" do |r|
-  [200, { "Content-Type" => "text/plain"}, ["something"]]
-end
-
-s.map "/food", Food.new
-
-s.start 2000

data/examples/mixin.rb

@@ -1,22 +0,0 @@
-#!/usr/bin/env ruby
-
-require_relative "../lib/sansom" rescue require "sansom"
-
-class Mixin < Hash
-  include Sansomable
-  
-  def template
-    get "/sansomable" do |r|
-      [200, { "Content-Type" => "text/plain"}, ["Sansomable Hash"]]
-    end
-  end
-end
-
-s = Sansom.new
-
-s.get "/" do |r| 
-  [200, { "Content-Type" => "text/plain"}, ["root"]] 
-end
-
-s.map "/mixins", Mixin.new
-s.start 3002