knot 0.0.1

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rvmrc

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+environment_id="ruby-1.9.3-p125@knot"
+
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+  [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]] &&
+    \. "${rvm_path:-$HOME/.rvm}/hooks/after_use" || true
+  if [[ $- == *i* ]] # check for interactive shells
+  then echo "Using: $(tput setaf 2)$GEM_HOME$(tput sgr0)" # show the user the ruby and gemset they are using in green
+  else echo "Using: $GEM_HOME" # don't use colors in non-interactive shells
+  fi
+else
+  rvm --create use  "$environment_id" || {
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  }
+fi

data/Gemfile

@@ -0,0 +1,13 @@
+source 'http://rubygems.org'
+
+gem "rack"
+gem "rack-protection"
+gem "yajl-ruby"
+
+
+group :test, :development do
+  gem "rack-test"
+  gem "rspec"
+  gem "rake"
+  gem "unicorn"
+end

data/Gemfile.lock

@@ -0,0 +1,37 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    kgio (2.7.4)
+    rack (1.4.1)
+    rack-protection (1.2.0)
+      rack
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    raindrops (0.10.0)
+    rake (0.9.2.2)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    unicorn (4.3.1)
+      kgio (~> 2.6)
+      rack
+      raindrops (~> 0.7)
+    yajl-ruby (1.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rack
+  rack-protection
+  rack-test
+  rake
+  rspec
+  unicorn
+  yajl-ruby

data/README

@@ -0,0 +1,2 @@
+# Knot
+It's pretty much top secret.

data/Rakefile

@@ -0,0 +1,15 @@
+task :default => ["knot:test"]
+
+namespace :knot do
+
+  desc "Start the server with unicorn"
+  task :start do
+    Kernel.system("unicorn -c unicorn.conf.rb")
+  end
+
+  desc "Run Tests"
+  task :test do
+    Kernel.system("bundle exec rspec")
+  end
+
+end

data/config.ru

@@ -0,0 +1,6 @@
+$:<< File.dirname(__FILE__)
+$:<< File.join(File.dirname(__FILE__), "lib")
+
+require 'spec/acceptance/test_app'
+
+run TestApp.new

data/knot.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'knot/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "knot"
+  gem.version       = Knot::VERSION
+  gem.authors       = ["Brian Pratt"]
+  gem.email         = ["brian@8thlight.com"]
+  gem.description   = "Knot"
+  gem.summary       = "Build ruby apps"
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency('rack')
+  gem.add_dependency('rack-protection')
+  gem.add_dependency('yajl-ruby')
+end

data/lib/knot/application/configuration.rb

@@ -0,0 +1,25 @@
+module Knot
+  class Application
+    class Configuration
+      attr_writer :template_path
+
+      def add_router(router)
+        routers << router
+      end
+
+      def routers
+        @routers ||= []
+      end
+
+      def template_path
+        @template_path ||= "templates/"
+      end
+
+      def finalize!
+        routers.each do |router|
+          router.config.knot_template_home = template_path
+        end
+      end
+    end
+  end
+end

data/lib/knot/application.rb

@@ -0,0 +1,59 @@
+require 'knot/dispatch/router'
+require 'knot/application/configuration'
+require 'rack/protection'
+
+module Knot
+  class Application
+    class << self;
+      alias :new_without_middleware :new
+
+      def new
+        app = new_without_middleware
+        return build_rack(app).to_app
+      end
+
+      def build_rack(app)
+        builder = Rack::Builder.new
+        builder.use Rack::Session::Cookie
+        builder.use Rack::Protection
+        builder.run app
+        return builder
+      end
+
+      def configure(&block)
+        block.call(config)
+        config.finalize!
+      end
+
+      def config
+        @config ||= Knot::Application::Configuration.new
+      end
+    end
+
+    def call(env)
+      begin
+        route_request(env)
+      rescue => e
+        return [500, {'Content-Type' => 'text/html'}, ["An error occured: ", e.message + "\n", e.backtrace.join("\n")]]
+      end
+    end
+
+    def config
+      self.class.config
+    end
+
+    def route_request(env)
+      config.routers.each do |router|
+        begin
+          request = Rack::Request.new(env)
+          response = router._call!(request)
+          return response.to_rack
+        rescue Knot::Dispatch::NoRouteError
+          next
+        end
+      end
+
+      return [404, {"Content-Type" => "text/html"}, ["Aw snap"]]
+    end
+  end
+end

data/lib/knot/dispatch/filter.rb

@@ -0,0 +1,27 @@
+require 'knot/dispatch'
+
+module Knot::Dispatch
+  class Filter
+    attr_reader :block
+
+    def initialize(name, options = {}, &block)
+      @name = name
+      @options = {:only => [], :except => []}.merge(options)
+      @block = block
+    end
+
+    def apply_to?(route)
+      (only.empty? && except.empty?) || 
+        (!only.empty? && only.include?(route.name)) ||
+        (!except.empty? && !except.include?(route.name))
+    end
+
+    def only
+      @options[:only]
+    end
+
+    def except
+      @options[:except]
+    end
+  end
+end

data/lib/knot/dispatch/path.rb

@@ -0,0 +1,38 @@
+require 'knot/dispatch'
+
+module Knot::Dispatch
+  class Path
+    def self.match?(subject, other)
+      return false if chunks(subject).length != chunks(other).length
+      pairs(subject, other).all? do |subject_chunk, other_chunk|
+        variable?(subject_chunk) || subject_chunk == other_chunk
+      end
+    end
+
+    def self.path_params(subject, request)
+      url_params = pairs(subject, request.path).inject({}) do |hash, values|
+        key, value = values
+        hash[symbolize(key)] = value if variable?(key)
+        hash
+      end
+    end
+
+    private
+
+    def self.pairs(subject, other)
+      chunks(subject).zip(chunks(other))
+    end
+
+    def self.symbolize(value)
+      value.sub(":", "").to_sym
+    end
+
+    def self.variable?(chunk)
+      chunk[0, 1] == ":"
+    end
+
+    def self.chunks(path)
+      path.split("/")
+    end
+  end
+end

data/lib/knot/dispatch/response.rb

@@ -0,0 +1,10 @@
+require 'knot/dispatch'
+require 'rack/response'
+
+module Knot::Dispatch
+  class Response < ::Rack::Response
+    def to_rack
+      [status, headers, body]
+    end
+  end
+end

data/lib/knot/dispatch/route.rb

@@ -0,0 +1,22 @@
+require 'knot/dispatch'
+require 'knot/dispatch/path'
+
+module Knot::Dispatch
+  class Route
+    attr_reader :path, :http_method, :name, :block
+
+    def initialize(http_method, name, path, &block)
+      @http_method, @name, @path, @block = http_method.to_s.upcase, name, path, block
+    end
+
+    def match?(request)
+      http_method_match?(request) && Path.match?(@path, request.path)
+    end
+
+    private
+
+    def http_method_match?(request)
+      request.request_method == @http_method 
+    end
+  end
+end

data/lib/knot/dispatch/router/api.rb

@@ -0,0 +1,39 @@
+require 'knot/dispatch'
+
+module Knot::Dispatch
+  class Router
+    module API
+      def get(name, path, &block)
+        config.register_route(:get, name, path, &block)
+      end
+
+      def post(name, path, &block)
+        config.register_route(:post, name, path, &block)
+      end
+
+      def put(name, path, &block)
+        config.register_route(:put, name, path, &block)
+      end
+
+      def delete(name, path, &block)
+        config.register_route(:delete, name, path, &block)
+      end
+
+      def patch(name, path, &block)
+        config.register_route(:patch, name, path, &block)
+      end
+
+      def head(name, path, &block)
+        config.register_route(:head, name, path, &block)
+      end
+
+      def options(name, path, &block)
+        config.register_route(:options, name, path, &block)
+      end
+
+      def filter(name, options, &block)
+        config.add_filter(name, options, &block)
+      end
+    end
+  end
+end

data/lib/knot/dispatch/router/config.rb

@@ -0,0 +1,53 @@
+require 'knot/dispatch/route'
+require 'knot/dispatch/filter'
+require 'knot/util'
+
+module Knot
+  module Dispatch
+    class Router
+      class Config
+        attr_reader :router_name
+
+        def initialize(router)
+          @router_name = router.to_s
+        end
+
+        def routes
+          @routes ||= []
+        end
+
+        def register_route(http_method, name, path, &block)
+          routes << Knot::Dispatch::Route.new(http_method, name, path, &block)
+        end
+
+        def filters
+          @filters ||= []
+        end
+
+        def add_filter(name, options, &block)
+          filters << Knot::Dispatch::Filter.new(name, options, &block)
+        end
+
+        def knot_template_home=(base_path)
+          @template_paths = template_paths.
+            reject { |path| path == base_path }.
+            map    { |path| path.prepend(base_path + "/") }
+          template_paths << base_path
+        end
+
+        def template_paths
+          @template_paths ||= [Knot::Util.to_snake(router_name)]
+        end
+
+        def applicable_filters(route)
+          filters.select {|f| f.apply_to?(route)}
+        end
+
+        def reset!
+          @routes = []
+          @filters = []
+        end
+      end
+    end
+  end
+end

data/lib/knot/dispatch/router/context.rb

@@ -0,0 +1,39 @@
+require 'knot/render'
+require 'knot/dispatch'
+require 'yajl/json_gem'
+
+module Knot::Dispatch
+  class Router
+    module Context
+      def params
+        request.params
+      end
+
+      def status(code)
+        response.status = code
+      end
+
+      def redirect(uri)
+        status(302)
+        response.headers['Location'] = uri
+        respond!
+      end
+
+      def json(obj)
+        response.body << obj.to_json
+        response.headers["Content-Type"] = "application/json"
+        respond!
+      end
+
+      def render(filename, options = {})
+        response.body << Knot::Render.render(filename, _config.template_paths, options)
+        respond!
+      end
+
+      # terminate processing and return to router to handle the given response
+      def respond!
+        throw(:halt, response)
+      end
+    end
+  end
+end

data/lib/knot/dispatch/router.rb

@@ -0,0 +1,53 @@
+require 'knot/dispatch'
+require 'knot/dispatch/router/config'
+require 'knot/dispatch/router/context'
+require 'knot/dispatch/router/api'
+require 'knot/dispatch/response'
+
+module Knot::Dispatch
+  class Router
+    include Knot::Dispatch::Router::Context
+    extend Knot::Dispatch::Router::API
+
+    def self._call!(request)
+      new(request)._call!
+    end
+
+    def self.config
+      @config ||= Knot::Dispatch::Router::Config.new(self)
+    end
+
+    attr_reader :request, :response
+
+    def initialize(request)
+      @request = request
+      @response = Knot::Dispatch::Response.new
+    end
+
+    def _call!
+      route = _config.routes.find { |route| route.match?(request) }
+
+      raise Knot::Dispatch::NoRouteError, "no route matches #{request.path}" if route.nil?
+
+      request.params.merge! Path.path_params(route.path, request)
+
+      blocks = _config.applicable_filters(route).map(&:block)
+      blocks << route.block
+
+      catch(:halt) {
+        blocks.map do |block|
+          result = instance_eval &block
+          response.body << result if result.is_a?(String)
+        end.last
+      }
+
+      return response
+    end
+
+  private
+
+    def _config
+      self.class.config
+    end
+  end
+end

data/lib/knot/dispatch.rb

@@ -0,0 +1,5 @@
+module Knot
+  module Dispatch
+    NoRouteError = Class.new(RuntimeError)
+  end
+end

data/lib/knot/render/binding.rb

@@ -0,0 +1,16 @@
+module Knot
+  module Render
+    class Binding
+      def initialize(options)
+        options.each do |key, value|
+          instance_variable_set("@#{key.to_s}", value)
+          self.class.instance_eval { attr_reader key }
+        end
+      end
+
+      def get_binding
+        binding
+      end
+    end
+  end
+end

data/lib/knot/render/template.rb

@@ -0,0 +1,30 @@
+module Knot
+  module Render
+    class Template
+      def self.for(filename, search_paths)
+        filename += ".html.erb"
+        directory = search_paths.find { |path| File.exist?(File.join(path, filename)) }
+
+        raise NoTemplateError, "couldn't find template #{filename} in #{search_paths.join(", ")}" if directory.nil?
+
+        template_for(File.join(directory, filename))
+      end
+
+      def self.template_for(filename)
+        if cache.keys.include?(filename)
+          cache[filename]
+        else
+          cache[filename] = ERB.new(File.read(filename))
+        end
+      end
+
+      def self.cache
+        @cache ||= {}
+      end
+
+      def self.clear_cache!
+        @cache = {}
+      end
+    end
+  end
+end

data/lib/knot/render.rb

@@ -0,0 +1,16 @@
+require 'knot/render/binding'
+require 'knot/render/template'
+
+module Knot
+  module Render
+
+    NoTemplateError = Class.new(RuntimeError)
+
+    def self.render(filename, search_paths, options = {})
+      binding = Knot::Render::Binding.new(options)
+      template = Knot::Render::Template.for(filename, search_paths)
+
+      return template.result(binding.get_binding)
+    end
+  end
+end

data/lib/knot/util.rb

@@ -0,0 +1,11 @@
+module Knot
+  class Util
+    def self.to_snake(str)
+      str.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase 
+    end
+  end
+end

data/lib/knot.rb

@@ -0,0 +1,10 @@
+require 'knot/dispatch/router'
+require 'knot/application'
+
+module Knot
+  Router = Dispatch::Router
+
+  def self.env
+    ENV['RACK_ENV']
+  end
+end

data/spec/acceptance/acceptance_spec.rb

@@ -0,0 +1,73 @@
+require 'rack/test'
+require './spec/acceptance/test_app'
+
+describe "basic test for API" do
+  let(:app) { TestApp.new }
+  let!(:request) { Rack::MockRequest.new(app) }
+
+  it "routes to root" do
+    response = request.get "/"
+    response.body.should == "Huzzah"
+  end
+
+  it "gets URL params" do
+    response = request.get "/greet/world"
+    response.body.should == "Hello, world"
+
+    other_response = request.get "/greet/nurse"
+    other_response.body.should == "Hello, nurse"
+  end
+
+  it "returns 404" do
+    response = request.get "/not_to_be_found"
+    response.status.should == 404
+    response.body.should == "Aw snap"
+  end
+
+  it "redirects" do
+    response = request.get "/onward"
+    response.should be_redirect
+    response.headers['Location'].should == "/greet/redirect"
+  end
+
+  context "json" do
+    it "renders json" do
+      response = request.get "/as_json"
+      response.status.should == 200
+      response.headers["Content-Type"].should == "application/json"
+      response.body.should == "{\"key\":\"value\"}"
+    end
+  end
+
+  context "when an exception is raised" do
+    it "returns 500" do
+      response = request.get "/raise_exception"
+      response.status.should == 500
+    end
+  end
+
+  context "filters" do
+    it "when filter is satisfied" do
+      response = request.get "/filter/pass"
+      response.body.should == "Filtered"
+    end
+
+    it "when filter is not satisfied" do
+      response = request.get "/filter/fail"
+      response.should be_redirect
+    end
+  end
+
+  context "templates" do
+    it "renders the template in the app's template path" do
+      response = request.get "/template/someone"
+      response.body.should == "<h1>Hello, someone,</h1>\n<p>from ERB!</p>\n"
+    end
+
+    it "renders the template in the router's template path if it exists" do
+      response = request.get "/template_override"
+      response.body.should == "Should render me.\n"
+    end
+  end
+end
+

data/spec/acceptance/templates/override.html.erb

@@ -0,0 +1 @@
+Shouldn't render me.

data/spec/acceptance/templates/test_router/override.html.erb

@@ -0,0 +1 @@
+Should render me.

data/spec/acceptance/templates/test_template.html.erb

@@ -0,0 +1,2 @@
+<h1>Hello, <%= name %>,</h1>
+<p>from ERB!</p>

data/spec/acceptance/test_app.rb

@@ -0,0 +1,50 @@
+require "knot"
+
+class TestRouter < Knot::Router
+
+  filter :redirect_unless_pass, :only => [:filter_test] do
+    redirect "/greet/nurse" unless params[:filter] == "pass"
+  end
+
+  def yay
+    "Huzzah"
+  end
+
+  get(:index, "/") { yay }
+
+  get :url_param_test, "/greet/:slug" do
+    "Hello, " + params[:slug]
+  end
+
+  get :redirect_test, "/onward" do
+    redirect "/greet/redirect"
+  end
+
+  get :json_test, "/as_json" do
+    json key: "value"
+  end
+
+  get :exception_test, "/raise_exception" do
+    raise "whoa nelly!!"
+  end
+
+  get :filter_test, "/filter/:filter" do
+    "Filtered"
+  end
+
+  get :template_test, "/template/:name" do
+    render 'test_template', :name => params[:name]
+  end
+
+  get :template_override_test, "/template_override" do
+    render 'override'
+  end
+end
+
+class TestApp < Knot::Application
+  configure do |config|
+    config.add_router TestRouter
+    config.template_path = "spec/acceptance/templates"
+  end
+end
+

data/spec/knot/dispatch/filter_spec.rb

@@ -0,0 +1,31 @@
+require 'knot/dispatch/filter'
+
+describe Knot::Dispatch::Filter do
+  context "apply_to?" do
+    context "apply to all" do
+      it "applies to any route" do
+        filter = Knot::Dispatch::Filter.new(:example) { "called" }
+        filter.apply_to?(stub(:name => :route)).should be_true
+      end
+    end
+
+    context "only" do
+      it "applies if the route is in the only list" do
+        filter = Knot::Dispatch::Filter.new(:example, :only => [:route]) { "called" }
+        filter.apply_to?(stub(:name => :route)).should be_true
+      end
+
+      it "does not apply if the route is not in the only list" do
+        filter = Knot::Dispatch::Filter.new(:example, :only => [:route]) { "called" }
+        filter.apply_to?(stub(:name => :another)).should_not be_true
+      end
+    end
+
+    context "except" do
+      it "applies if the route is not in the except list" do
+        filter = Knot::Dispatch::Filter.new(:example, :except => [:route]) { "called" }
+        filter.apply_to?(stub(:name => :another)).should be_true
+      end
+    end
+  end 
+end

data/spec/knot/dispatch/path_spec.rb

@@ -0,0 +1,32 @@
+require 'knot/dispatch/path'
+
+describe Knot::Dispatch::Path do
+  context ".match?" do
+    subject { Knot::Dispatch::Path }
+
+    it "fails for wrong route" do
+      subject.match?("/test", "/asdf").should_not be_true
+    end
+
+    it "matches a simple path" do
+      subject.match?("/test", "/test").should be_true
+    end
+
+    it "matches a path with param injection" do
+      subject.match?("/test/:id", "/test/1").should be_true
+    end
+
+    it "matches a nested path with multiple params injected" do
+      subject.match?("/test/:foo/and/:bar/edit","/test/1/and/2/edit").should be_true
+    end
+  end
+
+  context ".path_params" do
+    it "gets the variables from path and inserts them into a hash" do
+      request = stub(:path => "/test/1/and/2/edit")
+
+      vars = Knot::Dispatch::Path.path_params("/test/:foo/and/:bar/edit", request)
+      vars.should == {:foo => "1", :bar => "2"}
+    end
+  end
+end

data/spec/knot/dispatch/response_spec.rb

@@ -0,0 +1,12 @@
+require 'knot/dispatch/response'
+
+describe Knot::Dispatch::Response do
+  context "#to_rack" do
+    it "returns the array for rack interface" do
+      response = Knot::Dispatch::Response.new
+      response.body << 'Test'
+      response.status = 200
+      response.to_rack.should == [200, {"Content-Type"=>"text/html"}, ['Test']]
+    end
+  end
+end

data/spec/knot/dispatch/route_spec.rb

@@ -0,0 +1,30 @@
+require 'knot/dispatch/route'
+
+describe Knot::Dispatch::Route do
+  it "target path" do
+    route = Knot::Dispatch::Route.new("GET", :test, "/test")
+    route.path.should == "/test"
+  end
+
+  it "http method" do
+    route = Knot::Dispatch::Route.new("GET", :test, "/test")
+    route.http_method.should == "GET"
+  end
+
+  context "#match?" do
+    let(:route) { Knot::Dispatch::Route.new("GET", :test, "/test") }
+
+    it "delegates to Path" do
+      request = stub(:request_method => "GET", :path => "/test", :params => {})
+      Knot::Dispatch::Path.should_receive(:match?).with(route.path, request.path).and_return(true)
+      route.match?(request).should be_true
+    end
+
+    it "filters paths out by http_method" do
+      request = stub(:request_method => "POST", :path => "/test", :params => {})
+      Knot::Dispatch::Path.should_receive(:match?).never
+      route.match?(request).should_not be_true
+    end
+  end
+end
+

data/spec/knot/dispatch/router/config_spec.rb

@@ -0,0 +1,12 @@
+require 'knot/dispatch/router/config'
+
+describe Knot::Dispatch::Router::Config do
+  context "template_paths" do
+    it "defaults to an array with router's directory name in it" do
+      AnExampleRouter = Class.new unless defined?(AnExampleRouter)
+
+      config = Knot::Dispatch::Router::Config.new(AnExampleRouter)
+      config.template_paths.should == ["an_example_router"]
+    end
+  end
+end

data/spec/knot/dispatch/router_spec.rb

@@ -0,0 +1,111 @@
+require 'knot/dispatch/router'
+
+describe Knot::Dispatch::Router do
+  before(:each) { router.config.reset! }
+  let(:router) { Knot::Dispatch::Router }
+
+  context "definition/configuration" do
+    context ".routes" do
+      it "has collection of routes" do
+        router.config.routes.should == []
+      end
+
+      context "registration" do
+        [:get, :post, :put, :delete, :patch, :head, :options].each do |http_method|
+          it "registers a #{http_method} route" do
+            expect {
+              router.send(http_method, :hey, "/") { "hey" }
+            }.to change { router.config.routes.size }.by(1)
+
+            router.config.routes.first.http_method.should == http_method.to_s.upcase
+          end
+        end
+      end
+    end
+
+    context ".call!" do
+      before(:each) do
+        router.get(:index, "/")
+        router.post(:test_action, "/test_action") do
+          "test_sentinel"
+        end
+      end
+
+      it "finds the route if it exists" do
+        request = stub(:request_method => "POST", :params => {}, :path => "/test_action")
+        router._call!(request).should_not raise_error Knot::Dispatch::NoRouteError
+      end
+
+      it "returns a response" do
+        request = stub(:request_method => "POST", :params => {}, :path => "/test_action")
+        router._call!(request).should be_a(Knot::Dispatch::Response)
+      end
+
+      it "raises NoRouteError if the route isn't found" do
+        request = stub(:request_method => "POST", :params => {}, :path => "/nonsense_path")
+
+        expect {
+          router._call!(request)
+        }.to raise_error Knot::Dispatch::NoRouteError
+      end
+
+      it "triggers the action for the route" do
+        request = stub(:request_method => "POST", :params => {}, :path => "/test_action")
+        router._call!(request).body.should == ["test_sentinel"]
+      end
+    end
+
+    context ".filter" do
+      it "defines a filter" do
+        request = stub(:request_method => "GET", :params => {}, :path => "/path")
+
+        router.filter :example_filter, :only => [:example] do
+          response.body << "Filtered!"
+          respond! # kill processing and respond immediately
+        end
+
+        router.get(:example, "/path") do |*_|
+          "Shouldn't get here"
+        end
+
+        router._call!(request).body.should == ["Filtered!"]
+      end
+    end
+  end
+
+  context "execution" do
+    let(:request) { stub(:request_method => "POST", :params => {:example_param => true}, :path => "/") }
+
+    context "#params" do
+      it "gives access to the request's params" do
+        router = Knot::Dispatch::Router.new(request)
+        router.params.should == request.params
+      end
+    end
+
+    context "#redirect" do
+      it "sets status and location header" do
+        router = Knot::Dispatch::Router.new(request)
+        response = catch(:halt) { router.redirect('http://www.google.com') }
+        response.status.should == 302
+        response.headers['Location'].should == "http://www.google.com"
+      end
+    end
+
+    context "#json" do
+      it "returns the object in json" do
+        router = Knot::Dispatch::Router.new(request)
+        response = catch(:halt) { router.json(:foo => "bar") }
+        JSON.parse(response.body.first).should == {'foo' => 'bar'}
+      end
+    end
+
+    context "#status" do
+      it "sets the status code on the response" do
+        router = Knot::Dispatch::Router.new(request)
+        router.status(422)
+        router.response.status.should == 422
+      end
+    end
+  end
+end

data/spec/knot/render/binding_spec.rb

@@ -0,0 +1,13 @@
+require 'knot/render/binding'
+
+describe Knot::Render::Binding do
+  it "sets attributes as instance variables" do
+    binding = Knot::Render::Binding.new(:foo => "bar")
+    binding.foo.should == "bar"
+  end
+
+  it "gets the binding for the template to run against" do
+    binding = Knot::Render::Binding.new(:foo => "bar")
+    binding.get_binding.should be_a ::Binding
+  end
+end

data/spec/knot/render_spec.rb

@@ -0,0 +1,34 @@
+require 'knot/render'
+
+describe Knot::Render do
+  context ".render" do
+    it "renders the template if found in given search path" do
+      filename = "dir/filename.html.erb"
+      File.stub(:exist?).with(filename).and_return(true)
+      File.stub(:read).with(filename).and_return("template")
+
+      Knot::Render.render("filename", ["dir"]).should == "template"
+    end
+
+    it "raises NoTemplateError if it can't find the template" do
+      filename = "dir/filename.html.erb"
+      File.stub(:exist?).with(filename).and_return(false)
+
+      expect {
+        Knot::Render.render("filename", ["dir"])
+      }.to raise_error Knot::Render::NoTemplateError
+    end
+
+    it "caches the results of the render" do
+      Knot::Render::Template.clear_cache!
+      filename = "dir/filename.html.erb"
+
+      File.stub(:exist?).with(filename).and_return(true)
+      File.should_receive(:read).once.with(filename).and_return("template")
+
+      Knot::Render.render("filename", ["dir"])
+      cached_result = Knot::Render.render("filename", ["dir"])
+      cached_result.should == "template"
+    end
+  end
+end

data/spec/knot/util_spec.rb

@@ -0,0 +1,9 @@
+require 'knot/util'
+
+describe Knot::Util do
+  context ".to_snake" do
+    it "converts a constant or camelcase to snake case" do
+      Knot::Util.to_snake("HelloWorld").should == "hello_world"
+    end
+  end
+end

data/unicorn.conf.rb

@@ -0,0 +1,5 @@
+listen 4567 # by default Unicorn listens on port 8080
+worker_processes 1 # this should be >= nr_cpus
+# pid "/path/to/app/shared/pids/unicorn.pid"
+# stderr_path "/path/to/app/shared/log/unicorn.log"
+# stdout_path "/path/to/app/shared/log/unicorn.log"

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: knot
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Brian Pratt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-protection
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Knot
+email:
+- brian@8thlight.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .rspec
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- README
+- Rakefile
+- config.ru
+- knot.gemspec
+- lib/knot.rb
+- lib/knot/application.rb
+- lib/knot/application/configuration.rb
+- lib/knot/dispatch.rb
+- lib/knot/dispatch/filter.rb
+- lib/knot/dispatch/path.rb
+- lib/knot/dispatch/response.rb
+- lib/knot/dispatch/route.rb
+- lib/knot/dispatch/router.rb
+- lib/knot/dispatch/router/api.rb
+- lib/knot/dispatch/router/config.rb
+- lib/knot/dispatch/router/context.rb
+- lib/knot/render.rb
+- lib/knot/render/binding.rb
+- lib/knot/render/template.rb
+- lib/knot/util.rb
+- spec/acceptance/acceptance_spec.rb
+- spec/acceptance/templates/override.html.erb
+- spec/acceptance/templates/test_router/override.html.erb
+- spec/acceptance/templates/test_template.html.erb
+- spec/acceptance/test_app.rb
+- spec/knot/dispatch/filter_spec.rb
+- spec/knot/dispatch/path_spec.rb
+- spec/knot/dispatch/response_spec.rb
+- spec/knot/dispatch/route_spec.rb
+- spec/knot/dispatch/router/config_spec.rb
+- spec/knot/dispatch/router_spec.rb
+- spec/knot/render/binding_spec.rb
+- spec/knot/render_spec.rb
+- spec/knot/util_spec.rb
+- unicorn.conf.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Build ruby apps
+test_files:
+- spec/acceptance/acceptance_spec.rb
+- spec/acceptance/templates/override.html.erb
+- spec/acceptance/templates/test_router/override.html.erb
+- spec/acceptance/templates/test_template.html.erb
+- spec/acceptance/test_app.rb
+- spec/knot/dispatch/filter_spec.rb
+- spec/knot/dispatch/path_spec.rb
+- spec/knot/dispatch/response_spec.rb
+- spec/knot/dispatch/route_spec.rb
+- spec/knot/dispatch/router/config_spec.rb
+- spec/knot/dispatch/router_spec.rb
+- spec/knot/render/binding_spec.rb
+- spec/knot/render_spec.rb
+- spec/knot/util_spec.rb