renee 0.3.11 → 0.4.0.pre1

data/site/views/settings.md

@@ -0,0 +1,19 @@
+# Settings
+
+Configuration in Renee is simply using the `#setup` command to set
+the appropriate options within a Renee application:
+
+    :::ruby
+    Renee { ... }.setup do
+      views_path "./views"
+      include Some::Module
+    end
+
+The available configuration options are:
+
+ * `views_path`: The path to the templates within an application.
+ * `include`: Register a module within an application.
+ * `register_variable_type`: Allows [registration of arbitrary param types](/variable-types).
+
+More options are to come based on Renee configuration needs as they arise.
+

data/site/views/team-renee.md

@@ -0,0 +1,13 @@
+# Team Renee
+
+* [Arthur](https://github.com/achiu)
+* [Josh](https://github.com/joshbuddy)
+* [Nathan](https://github.com/nesquena)
+
+Josh thought this up when he started working on a new routing DSL for Goliath.
+Once you combine the controller and the router, everything is easy!
+Nathan did the rendering, lots of ideas and amazing documentation.
+Arthur mumbles things and makes test pass. Before he makes them pass, he first makes them exist.
+
+Oh yeah, and there is also Renee. She didn't write any of this, just keeps handing me
+cups of really strong tea while I work on it. Thank you.

data/site/views/tutorial.md

@@ -0,0 +1,57 @@
+# Tutorial
+
+This is the most basic ever tutorial, and admittedly, a lot of it is boilerplate setup. But hopefully, this demonstrates how easy it is to get up and running with Renee.
+
+## Create a project and install your gems
+
+    :::terminal
+    $> mkdir renee-tutorial
+    $> cd renee-tutorial
+    $> bundle init
+    Writing new Gemfile to /Users/joshbuddy/Gemfile/renee-tutorial
+    $> mate .
+
+Now in your editor, type:
+
+    :::ruby
+    source "http://rubygems.org"
+
+    gem 'renee', '~> 0.3.0'
+    gem 'shotgun'
+
+Go back to your tutorial and install that dog!
+
+    :::terminal
+    $> bundle
+    Installing bundler (1.0.21) 
+    Installing callsite (0.0.6) 
+    Installing rack (1.3.5) 
+    Installing renee-core (0.2.0) 
+    Installing tilt (1.3.3) 
+    Installing renee-render (0.2.0) 
+    Installing renee (0.2.0) 
+    Installing shotgun (0.9) 
+    Your bundle is complete! Use `bundle show [gemname]` to see where a bundled gem is installed.
+
+## Write a hello world
+
+In your editor, create the file `config.ru`. Now, edit that file.
+
+    :::ruby
+    require 'renee'
+    
+    run Renee {
+      halt "hello world!"
+    }
+
+Back in your terminal, run:
+
+    :::terminal
+    $> bundle exec shotgun
+    == Shotgun/WEBrick on http://127.0.0.1:9393/
+    [2011-10-19 21:53:26] INFO  WEBrick 1.3.1
+    [2011-10-19 21:53:26] INFO  ruby 1.8.7 (2011-06-30) [i686-darwin11.2.0]
+    [2011-10-19 21:53:26] INFO  WEBrick::HTTPServer#start: pid=4312 port=9393
+
+Now, point your browser to `http://localhost:9393/`! Enjoy!
+

data/site/views/variable-types.md

@@ -0,0 +1,57 @@
+# Variable types
+
+Renee makes it easy to add variable types and use them!
+
+## Registering
+
+To create a variable type, in your [setup block](/settings), add a #register_variable_type call. Example:
+
+    :::ruby
+    register_variable_type(:hex,       # The name
+      /[0-9a-f]{6}/).                  # Part to capture
+      on_transform { |v| v.to_i(16) }. # How to transform
+      raise_on_error!                  # What to do when you can't
+                                       #   capture
+
+First, a registered type needs to have a name. Then, a regexp specifying what to match needs to be provided. If you want to transform the result, use `#on_transform` to pass a block to be called when this type is being used. If a type is attempted to be used, and the regexp doesn't manage to capture anything, the error handler is used to determine what to do. By default, there is no error handler, and so, your programs execution will continue normally. However, if you use`#on_error`, you can supply a block to be called in the event of an error. As a convenience, there is a `#raise_on_error!` method that will halt with a 400, or, if you choose, any HTTP error code you wish (which is an optional parameter to `#raise_on_error!`).
+
+## Default types
+
+By default, `:int` and `:integer` will ensure your variable is an `Integer`.
+
+## Errors
+
+The `#on_error` handler will accept a block. This block will then be executed in the context of your application. Feel free to `#render`, `#halt`, or do anything else you desire.
+
+## Compound types
+
+Types can also be composed from other defined types by supplying a list of other types. Here is an example:
+
+    :::ruby
+    regster_variable_type(:hex,    /0x[0-9a-f]+/).on_transform{|v| v.to_i(16)}
+    regster_variable_type(:octal,  /0[0-7]+/)    .on_transform{|v| v.to_i(8)}
+    regster_variable_type(:number, [:hex, :octal])
+
+Now, `:number` will attempt to use the `:hex` matcher, then, the `:octal` matcher. Compound types can even have their own error matching.
+
+## Aliasing types
+
+As well, you can create as many type aliases as you want. Just do this:
+
+    :::ruby
+    regster_variable_type(:num, :int)
+
+Now, you can refer to `:num` wherever you'd like.
+
+## Using variable types outside of path variables
+
+Sometimes, it would be nice to have access to the these variable types outside of the context of your path variables. If you wish, you can use `#transform` to recognize and transform an arbitrary `String`. Here is an example:
+
+    :::ruby
+    run Renee {
+      get.halt "It turns out octal 0123 is #{transform(:octal, "0123")} in decimal."
+    }.setup {
+      register_variable_type(:octal, /0[0-7]+/).on_transform{|v| v.to_i(8)}
+    }
+
+You'll get `It turns out octal 0123 is 83 in decimal.` What fun!

data/test.watchr

@@ -0,0 +1,61 @@
+ENV["WATCHR"] = "1"
+system 'clear'
+
+def growl(message)
+  growlnotify = `which growlnotify`.chomp
+  if not growlnotify.empty?
+    title = "Watchr Test Results"
+    image = message.include?('0 failures, 0 errors') ? "~/.watchr_images/passed.png" : "~/.watchr_images/failed.png"
+    options = "-w -n Watchr --image '#{File.expand_path(image)}' -m '#{message}' '#{title}'"
+    system %(#{growlnotify} #{options} &)
+  else
+    puts message
+  end
+end
+
+def run(cmd)
+  puts(cmd); `#{cmd}`
+end
+
+def run_test_file(file)
+  system('clear')
+  result = run(%Q(ruby -I"lib:test" -rubygems #{file}))
+  growl result.split("\n").last rescue nil
+  puts result
+end
+
+def run_all_tests
+  system('clear')
+  result = run "rake test"
+  growl result.split("\n").last rescue nil
+  puts result
+end
+
+def related_test_files(path)
+  Dir['test/**/*.rb'].select { |file| file =~ /#{File.basename(path).split(".").first}_test.rb/ }
+end
+
+watch('.*/test/test_helper\.rb') { run_all_tests }
+watch('.*/test/(.*).*_test\.rb') { |m| run_test_file(m[0]) }
+watch('.*/lib/(.*)\.rb')         { |m| related_test_files(m[0]).map {|tf| run_test_file(tf) } }
+
+# Ctrl-\
+Signal.trap 'QUIT' do
+  puts " --- Running all tests ---\n\n"
+  run_all_tests
+end
+
+@interrupted = false
+
+# Ctrl-C
+Signal.trap 'INT' do
+  if @interrupted then
+    @wants_to_quit = true
+    abort("\n")
+  else
+    puts "Interrupt a second time to quit"
+    @interrupted = true
+    Kernel.sleep 1.5
+    run_all_tests
+  end
+end

data/test/renee-core/chaining_test.rb

@@ -0,0 +1,33 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Route chaining" do
+
+  it "should chaining" do
+    type = { 'Content-Type' => 'text/plain' }
+    mock_app do
+      path('/').get { halt [200,type,['foo']] }
+      continue_routing.path('bar').put { halt [200,type,['bar']] }
+      continue_routing.path('bar').var.put { |id| halt [200,type,[id]] }
+      continue_routing.path('bar').var.get.halt { |id| "wow, nice to meet you " }
+    end
+    get '/'
+    assert_equal 200,   response.status
+    assert_equal 'foo', response.body
+    put '/bar'
+    assert_equal 200,   response.status
+    assert_equal 'bar', response.body
+    put '/bar/asd'
+    assert_equal 200,   response.status
+    assert_equal 'asd', response.body
+  end
+
+  it "should chain and halt with a non-routing method" do
+    type = { 'Content-Type' => 'text/plain' }
+    mock_app do
+      path('/').get.halt "hi"
+    end
+    get '/'
+    assert_equal 200,   response.status
+    assert_equal 'hi', response.body
+  end
+end

data/test/renee-core/env_accessors_test.rb

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+
+require File.expand_path('../test_helper', __FILE__)
+
+describe Renee::Core::EnvAccessors do
+  it "should allow accessing the env" do
+    @app = Renee.core {
+      self.test = 'hello'
+      path('test').get do
+        halt "test is #{test}"
+      end
+    }.setup {
+      env_accessor :test
+    }
+    get '/test'
+    assert_equal 200,   response.status
+    assert_equal 'test is hello', response.body
+  end
+
+  it "should raise when you try to access weird env keys" do
+    assert_raises(Renee::Core::EnvAccessors::InvalidEnvNameError) {
+      @app = Renee.core {
+        self.test_test = 'hello'
+      }.setup {
+        env_accessor "test.test"
+      }
+    }
+  end
+
+  it "should allow weird env keys if you map them" do
+    @app = Renee.core {
+      self.test_test = 'hello'
+      path('test').get do
+        halt "test is #{test_test}"
+      end
+    }.setup {
+      env_accessor "test.test" => :test_test
+    }
+    get '/test'
+    assert_equal 200,   response.status
+    assert_equal 'test is hello', response.body
+  end
+end

data/test/renee-core/include_test.rb

@@ -0,0 +1,14 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Route::Settings#include" do
+  it "should allow the inclusion of arbitrary modules" do
+    type = { 'Content-Type' => 'text/plain' }
+    @app = Renee.core {
+      halt :ok if respond_to?(:hi)
+    }.setup {
+      include Module.new { def hi; end }
+    }
+    get '/'
+    assert_equal 200,   response.status
+  end
+end

data/test/renee-core/request_context_test.rb

@@ -0,0 +1,70 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class AddHelloThereMiddleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    if env['hello']
+      env['hello'] << "there"
+    else
+      env['hello'] = 'hello'
+    end
+    @app.call(env)
+  end
+end
+
+class AddWhatsThatMiddleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    if env['hello']
+      env['hello'] << "that"
+    else
+      env['hello'] = 'whats'
+    end
+    @app.call(env)
+  end
+end
+
+describe "Route::Core::RequestContext#use" do
+  it "should allow the inclusion of arbitrary middlewares" do
+    type = { 'Content-Type' => 'text/plain' }
+    @app = Renee.core {
+      halt env['hello']
+    }.setup {
+      use AddHelloThereMiddleware
+    }
+    get '/'
+    assert_equal 200,     response.status
+    assert_equal 'hello', response.body
+  end
+
+  it "should call middlewares in sequence (1)" do
+    type = { 'Content-Type' => 'text/plain' }
+    @app = Renee.core {
+      halt env['hello']
+    }.setup {
+      use AddHelloThereMiddleware
+      use AddWhatsThatMiddleware
+    }
+    get '/'
+    assert_equal 200,     response.status
+    assert_equal 'hellothat', response.body
+  end
+
+  it "should call middlewares in sequence (2)" do
+    @app = Renee.core {
+      halt env['hello']
+    }.setup {
+      use AddWhatsThatMiddleware
+      use AddHelloThereMiddleware
+    }
+    get '/'
+    assert_equal 200,     response.status
+    assert_equal 'whatsthere', response.body
+  end
+end

data/test/renee-core/responding_test.rb

@@ -0,0 +1,128 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe Renee::Core::Responding do
+  describe "#interpret_response" do
+    it "should render from a number" do
+      mock_app do
+        path('/') { halt 200 }
+      end
+      get '/'
+      assert_equal 200,               response.status
+      assert_equal 'Status code 200', response.body
+    end
+
+    it "should render from a symbol" do
+      mock_app do
+        path('/') { halt :not_found }
+      end
+      get '/'
+      assert_equal 404,               response.status
+      assert_equal 'Status code 404', response.body
+    end
+
+    it "should render from a string" do
+      mock_app do
+        path('/') { halt "hello!" }
+      end
+      get '/'
+      assert_equal 200,      response.status
+      assert_equal 'hello!', response.body
+    end
+
+    it "should render from an array" do
+      mock_app do
+        path('/') { halt 500, "hello!" }
+      end
+      get '/'
+      assert_equal 500,      response.status
+      assert_equal 'hello!', response.body
+    end
+
+    it "should render from an array with a symbol" do
+      mock_app do
+        path('/') { halt :payment_required, "hello!" }
+      end
+      get '/'
+      assert_equal 403,      response.status
+      assert_equal 'hello!', response.body
+    end
+
+    it "should render a rack-sized array as a rack response" do
+      mock_app do
+        path('/') { halt [200, {'Content-Type' => 'text/plain'}, []] }
+      end
+      get '/'
+      assert_equal 200, response.status
+    end
+  end
+
+  describe "#respond" do
+    it "should allow respond! with response init arguments" do
+      mock_app do
+        get do
+          respond!("hello!", 403, "foo" => "bar")
+        end
+      end
+      get "/"
+      assert_equal 403,   response.status
+      assert_equal "bar",   response.headers["foo"]
+      assert_equal "hello!", response.body
+    end # respond!
+
+    it "should allow respond!" do
+      mock_app do
+        get do
+          respond! { status 403; headers :foo => "bar"; body "hello!" }
+        end
+      end
+      get "/"
+      assert_equal 403,   response.status
+      assert_equal "bar",   response.headers["foo"]
+      assert_equal "hello!", response.body
+    end # respond!
+
+    it "should allow respond" do
+      mock_app do
+        get do
+          halt(respond { status 403; headers :foo => "bar"; body "hello!" })
+        end
+      end
+      get "/"
+      assert_equal 403,   response.status
+      assert_equal "bar",   response.headers["foo"]
+      assert_equal "hello!", response.body
+    end # respond
+  end
+
+  describe "#redirect" do
+    it "should allow redirects" do
+      mock_app do
+        get { halt redirect('/hello') }
+      end
+
+      get '/'
+      assert_equal 302,      response.status
+      assert_equal "/hello", response.headers['Location']
+    end
+
+    it "should accept custom status codes" do
+      mock_app do
+        get { halt redirect('/hello', 303) }
+      end
+
+      get '/'
+      assert_equal 303,      response.status
+      assert_equal "/hello", response.headers['Location']
+    end
+
+    it "should allow redirect!" do
+      mock_app do
+        get { redirect!('/hello') }
+      end
+
+      get '/'
+      assert_equal 302,      response.status
+      assert_equal "/hello", response.headers['Location']
+    end
+  end
+end