sansom 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7b5864e32e2af6d42813deac99f743aa5f709377
-  data.tar.gz: 8f7778c22852629a41aa2056c957d68fd295e8b5
+  metadata.gz: f29764ffc96d04c4d04a32f6205e312501003245
+  data.tar.gz: bcc0fee0d61526e6d1f24eacf92af8aa16c182b6
 SHA512:
-  metadata.gz: cb966e9564c909969af9b96aa1e62e7b0eedaf345b573ee25090bf229e654bc0a978f29c0f3b736948261d0f8abf9090d84f11da3958ce83e996318b0ab10e02
-  data.tar.gz: d5fee84cb9b078c953f72a15ad227adb9d05aad20c801aab84640b8921f2cc06f7cd8b40f68ee21eda9cead4481faf901106c62c51fef82f5bd390f085576795
+  metadata.gz: a6e16f0fcc5e37418367b4e67cfd135d1d62a5aabda0ec7bd2866ad9e712dafe06c826eb8e8b921f3d648c2823d9055d5f3b1ce7a5e9b57031dd67538269351e
+  data.tar.gz: a011da7c29be9334651a240ec0a381825b3766ba4a3cab35659c1d83b1129f36747267f1af14da9e96701c69c7d5ded2743b1cb3f9151086c3d2b890def70035

data/ext/sansom/pine/matcher.cpp

@@ -0,0 +1,79 @@
+#include <iostream>
+#include "pattern.h"
+#include "ruby.h" // ruby header
+
+using namespace std;
+
+extern "C" void Init_matcher();
+static lpm::pattern * getPattern(VALUE self);
+static void matcher_gc_free(lpm::pattern *p);
+static VALUE matcher_allocate(VALUE klass);
+static VALUE matcher_initialize(VALUE self, VALUE rb_pattern);
+static VALUE matcher_matches(VALUE self, VALUE rb_str);
+static VALUE matcher_is_dynamic(VALUE self);
+static VALUE matcher_splats(VALUE self, VALUE rb_str);
+static VALUE matcher_mappings(VALUE self, VALUE rb_str);
+
+VALUE rb_cPine = Qnil;
+VALUE p_cMatcher = Qnil;
+
+void Init_matcher() {
+  rb_cPine = rb_define_class("Pine", rb_cObject);
+  p_cMatcher = rb_define_class_under(rb_cPine, "Matcher", rb_cObject);
+  rb_define_alloc_func(p_cMatcher, matcher_allocate);
+  rb_define_method(p_cMatcher, "initialize", RUBY_METHOD_FUNC(matcher_initialize), 1);
+  rb_define_method(p_cMatcher, "matches?", RUBY_METHOD_FUNC(matcher_matches), 1);
+  rb_define_method(p_cMatcher, "dynamic?", RUBY_METHOD_FUNC(matcher_is_dynamic), 0);
+  rb_define_method(p_cMatcher, "splats", RUBY_METHOD_FUNC(matcher_splats), 1);
+  rb_define_method(p_cMatcher, "mappings", RUBY_METHOD_FUNC(matcher_mappings), 1);
+}
+
+static lpm::pattern * getPattern(VALUE self) {
+    lpm::pattern *p;
+    Data_Get_Struct(self, lpm::pattern, p);
+    return p;
+}
+
+static void matcher_gc_free(lpm::pattern *p) {
+    if (p) delete p;
+    p = NULL;
+    ruby_xfree(p);
+}
+
+static VALUE matcher_allocate(VALUE klass) {
+    return Data_Wrap_Struct(klass, NULL, matcher_gc_free, ruby_xmalloc(sizeof(lpm::pattern)));
+}
+
+static VALUE matcher_initialize(VALUE self, VALUE rb_pattern) {
+    lpm::pattern *p = getPattern(self);
+    new (p) lpm::pattern(StringValueCStr(rb_pattern));
+    return Qnil;
+}
+
+static VALUE matcher_matches(VALUE self, VALUE rb_str) {
+  return *(getPattern(self)) == string(StringValueCStr(rb_str)) ? Qtrue : Qfalse;
+}
+
+static VALUE matcher_is_dynamic(VALUE self) {
+  return getPattern(self)->is_dynamic() ? Qtrue : Qfalse;
+}
+
+static VALUE matcher_splats(VALUE self, VALUE rb_str) {
+  lpm::pattern *p = getPattern(self);
+  list<string> splats = p->extract_splats(StringValueCStr(rb_str));
+  VALUE ary = rb_ary_new2(splats.size());
+  for (list<string>::iterator i = splats.begin(); i != splats.end(); i++) {
+    rb_ary_push(ary, rb_str_new2((*i).c_str()));;
+  }
+  return ary;
+}
+
+static VALUE matcher_mappings(VALUE self, VALUE rb_str) {
+  lpm::pattern *p = getPattern(self);
+  map<string, string> mappings = p->extract_mappings(StringValueCStr(rb_str));
+  VALUE hsh = rb_hash_new();
+  for (map<string, string>::iterator i = mappings.begin(); i != mappings.end(); i++) {
+    rb_hash_aset(hsh, rb_str_new2(i->first.c_str()),rb_str_new2(i->second.c_str()));
+  }
+  return hsh;
+}

data/ext/sansom/pine/pattern.cpp

@@ -0,0 +1,134 @@
+#include "pattern.h"
+
+namespace lpm {
+  bool pattern::operator==(const string &rhs) const { return matches(rhs); }
+  bool pattern::operator==(const pattern &rhs) const { return rhs._pattern == _pattern; }
+  bool pattern::operator!=(const string &rhs) const { return !(*this == rhs); }
+  
+  bool pattern::is_dynamic() const { return (_index.size() > 0); }
+  string pattern::pattern_str() const { return _pattern; }
+
+  bool pattern::matches(string cppstr) const {
+    if (_pattern[0] == ':') return true;
+    if (_pattern == cppstr) return true;
+    
+    char *pattern = (char *)_pattern.c_str();
+    char *str = (char *)cppstr.c_str();
+    int index_delta = 0;
+
+    for (auto i = _index.begin(); i != _index.end(); i++) {
+      unsigned idx = i->first;
+      string token = i->second;
+      
+      char *vptr = str+idx+index_delta;
+      char *succ = pattern+idx+token.length();
+      unsigned succlen = (i == _index.end()) ? 0 : next(i)->first-(idx+token.length());
+      unsigned vlen = _advance_to_str(vptr, succ, succlen);
+      if (strncmp(succ, vptr, succlen) != 0) return false;
+
+      index_delta += vlen;
+      index_delta -= token.length();
+    }
+    
+    return true;
+  }
+  
+  map<string, string> pattern::extract_mappings(string cppstr) const  {
+    map<string,string> m;
+    char *pattern = (char *)_pattern.c_str();
+    char *str = (char *)cppstr.c_str();
+    int index_delta = 0;
+    
+    if (_pattern[0] == ':') {
+      m[_pattern.substr(1,_pattern.length()-1)] = cppstr;
+      return m;
+    }
+
+    for (auto i = _index.begin(); i != _index.end(); i++) {
+      unsigned idx = i->first;
+      string token = i->second;
+      
+      char *vptr = str+idx+index_delta;
+      char *succ = pattern+idx+token.length();
+      unsigned succlen = (i == _index.end()) ? 0 : next(i)->first-(idx+token.length());
+      string value(vptr, _advance_to_str(vptr, succ, succlen));
+      
+      index_delta += value.length();
+      index_delta -= token.length();
+            
+      if (token[0] == '<' && token[token.length()-1] == '>') {
+        m[token.substr(1, token.length()-2)] = value;
+      }
+    }
+     
+    return m;
+  }
+   
+  list<string> pattern::extract_splats(string cppstr) const {
+    list<string> splats;
+    char *pattern = (char *)_pattern.c_str();
+    char *str = (char *)cppstr.c_str();
+    int index_delta = 0;
+   
+    for (auto i = _index.begin(); i != _index.end(); i++) {
+      unsigned idx = i->first;
+      string token = i->second;
+       
+      char *vptr = str+idx+index_delta;
+      char *succ = pattern+idx+token.length();
+      unsigned succlen = (i == _index.end()) ? 0 : next(i)->first-(idx+token.length());
+      string value(vptr, _advance_to_str(vptr, succ, succlen));
+     
+      index_delta += value.length();
+      index_delta -= token.length();
+       
+      if (token[0] == '*') splats.push_back(value);
+    }
+    return splats;
+  }
+  
+  void pattern::create(string ptrn) {
+    _pattern = ptrn;
+    char *cptrn = (char *)_pattern.c_str();
+    _index = _gen_indeces(cptrn,cptrn);
+  }
+ 
+  unsigned pattern::_advance_to_str(char *&ptr, char *str, unsigned n) const {
+    char *start = ptr;
+    while (*ptr != '\0' && (*str == '\0' || strncmp(ptr, str, n) != 0)) ptr++;
+    return (unsigned)(ptr-start);
+  }
+ 
+  map <unsigned, string> pattern::_gen_indeces(char *str, char *ptr) const {
+    // advance to wildcard
+    while (*ptr != '\0' && !at_wildcard(ptr)) ptr++;
+
+    if (*ptr == '\0') return map <unsigned, string>();
+    unsigned idx = ptr-str;
+    
+    // advance to characters after the pattern
+    char *start = ptr;
+    advance_past_wildcard(ptr);
+    unsigned token_len = (unsigned)(ptr-start);
+    
+    map <unsigned, string> recursive = _gen_indeces(str, ptr);
+    recursive[idx] = string(str+idx,token_len);
+    return recursive;
+  }
+  
+  //
+  // overrideable functions
+  //
+  
+  bool pattern::at_wildcard(char * ptr) const {
+    return (*ptr == '*' || *ptr == '<');
+  }
+  
+  void pattern::advance_past_wildcard(char *&ptr) const {
+    switch (*ptr) {
+      case '<': while (*ptr != '>') ptr++; ptr++; break;
+      case '*': ptr++; break;
+      default: break;
+    }
+  }
+}

data/ext/sansom/pine/pattern.h

@@ -0,0 +1,56 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <iostream>
+#include <list>
+#include <map>
+
+// TODO:
+//       1. write an iterator (exposes a value and a token)
+//       2. make more extensible
+//       3. improve _advance_to_str function to 
+
+namespace lpm {
+  using namespace std;
+  
+  class pattern {
+  public:
+    pattern(const char *ptrn) { create(ptrn); }
+    pattern(string ptrn) { create(ptrn); }
+    
+    bool operator==(const string &rhs) const;
+    bool operator==(const pattern &rhs) const;
+    bool operator!=(const string &rhs) const;
+  
+    // returns true if there are any wilcards/splats/etc in this
+    bool is_dynamic() const;
+    
+    // returns the pattern used
+    string pattern_str() const;
+    
+    // check if a string matches the this pattern
+    bool matches(string comp) const;
+    
+    // extracts all mappings from cppstr
+    map<string, string> extract_mappings(string cppstr) const;
+    
+    // extracts all splats from cppstr
+    list<string> extract_splats(string cppstr) const;
+  protected:
+    string _pattern;
+    map<unsigned, string> _index;
+    
+    void create(string ptrn);
+
+    // return true if ptr is at a wildcard sequence
+    virtual bool at_wildcard(char *ptr) const;
+    
+    // advance ptr to the character beyond a wildcard sequence.
+    virtual void advance_past_wildcard(char *&ptr) const;
+  private:
+    // advance ptr to the next occurance of str
+    unsigned _advance_to_str(char *&ptr, char *str, unsigned len) const;
+    map <unsigned, string> _gen_indeces(char *str, char *ptr) const;
+  };
+}

data/lib/sansom/sansomable.rb

@@ -24,7 +24,7 @@ module Sansomable
   def _call_handler handler, *args
     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
+    raise ResponseError, "Response must either be a rack response, string, or object" unless Rack::Lint.fastlint res
     res = [200, {}, [res.to_str]] if res.respond_to? :to_str
     res
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sansom
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Nathaniel Symer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-04 00:00:00.000000000 Z
+date: 2015-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -48,18 +48,15 @@ extensions:
 - ext/sansom/pine/extconf.rb
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- Gemfile
-- LICENSE.txt
-- README.md
-- changelog.md
 - ext/sansom/pine/extconf.rb
+- ext/sansom/pine/matcher.cpp
+- ext/sansom/pine/pattern.cpp
+- ext/sansom/pine/pattern.h
 - 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:
 - MIT

data/.gitignore

@@ -1,23 +0,0 @@
-ext/sansom/pine/Makefile
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp
-*.bundle
-*.so
-*.o
-*.a
-mkmf.log

data/Gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in ..gemspec
-gemspec

data/LICENSE.txt

@@ -1,22 +0,0 @@
-Copyright (c) 2014 Nathaniel Symer
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,232 +0,0 @@
-Sansom
-===
-
-No-nonsense web 'picowork' named after Sansom street in Philly, near where it was made.
-
-Philosophy
--
-
-***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 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.
-
-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. Therefore, 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`
-
-Or, you can clone this repo and use `gem build sansom.gemspec` to build the gem.
-
-Writing a Sansom app
--
-Writing a one-file application is trivial with Sansom:
-
-    # config.ru
-
-    require "sansom"
-	
-	class MyAPI
-	  include Sansomable
-	  def routes
-	  	# define routes here
-	  end
-	end
-    
-    run MyAPI.new
-    
-Defining Routes
--
-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.
-
-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
-
-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:
-    
-    # config.ru
-    
-    require "sansom"
-    
-    class Versioning
-      include Sansomable
-    end
-    
-    s = Versioning.new
-    s.mount "/v1", MyAPI.new
-    s.mount "/v2", MyNewAPI.new
-    
-    run s
-    
-Sansom routes vs Sinatra routes
--
-
-**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 routes become methods behind the scenes**: When a route is matched, Sinatra looks up the method and calls it.
-
-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 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
-    
-    require "sansom"
-    
-    s = Sansom.new
-    s.before do |r|
-      [200, {}, ["Preëmpted."]] if some_condition
-    end
-    
-You could use this for request statistics, caching, auth, etc.
-
-After filters
--
-
-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
-    
-    require "sansom"
-    
-    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"
-    
-    s = Sansom.new
-    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:
-
-    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
--
-
-`Sansom` uses trees to match routes. It follows a certain set of rules:
-
-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
-  	
-  	
-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`
-- 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: **11ms**<br />
-Sansom: **14ms**\*†<br />
-Sinatra: **28ms**<br />
-Rails: **34ms****
-
-(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 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
--
-
-* Multiple return types for routes
-
-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 its brevity.**

data/changelog.md

@@ -1,76 +0,0 @@
-Changelog
-=
-
-0.0.1
-
-(yanked due to bad name in Gemfile)
-
-0.0.2
-
-- Initial release
-
-0.0.3
-
-- Wrote custom tree implementation called Pine to replace RubyTree
-- Added `before` block
-
-Here's an example
-
-    s = Sansom.new
-
-    s.before do |r|
-      # Caveat: routes are mapped before this block is called
-      # Code executed before mapped route
-    end
-    
-    s.get "/" do |r|
-      [200, {}, ["Hello!"]]
-    end
-    
-    s.start 2000
-
-0.0.4
-
-- 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
-
-0.0.6
-
-- `before` block response checking
-
-0.0.7
-
-- Fixed bug where a wilcard path component would be ignored if it came last in the URL
-- Fixed a bug where async responses would be marked as bad by the fastlinter.
-
-0.1.0
-
-- PUBLIC RELEASE!
-- `after` block
-- Improved routing behavior & speed
-
-0.1.1
-
-- Fix bad bug in method_missing
-- Added better error handling (per-error handling and a generic block that gets called if no specific handler is present)
-
-0.1.2
-
-- 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/sansom.gemspec

@@ -1,24 +0,0 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
-Gem::Specification.new do |s|
-  s.name          = "sansom"
-  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."
-  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"
-
-  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"]
-
-  s.add_development_dependency "bundler", "~> 1.6"
-  s.add_dependency "rack", "~> 1"
-end