renee 0.4.0.pre1 → 0.4.0.pre2

data/Gemfile-renee

@@ -1,8 +0,0 @@
-source :rubygems
-
-gemspec :name => 'renee'
-
-group :development do
-  gem 'rdiscount'
-  gem 'rake'
-end

data/Gemfile-renee-core

@@ -1,8 +0,0 @@
-source :rubygems
-
-gemspec :name => 'renee-core'
-
-group :development do
-  gem 'rdiscount'
-  gem 'rake'
-end

data/Gemfile-renee-render

@@ -1,9 +0,0 @@
-source :rubygems
-
-gemspec :name => 'renee-core'
-gemspec :name => 'renee-render'
-
-group :development do
-  gem 'rdiscount'
-  gem 'rake'
-end

data/Gemfile-renee-session

@@ -1,9 +0,0 @@
-source :rubygems
-
-gemspec :name => 'renee-core'
-gemspec :name => 'renee-session'
-
-group :development do
-  gem 'rdiscount'
-  gem 'rake'
-end

data/Gemfile-renee-url-generation

@@ -1,8 +0,0 @@
-source :rubygems
-
-gemspec :name => 'renee-url-generation'
-
-group :development do
-  gem 'rdiscount'
-  gem 'rake'
-end

data/README-renee-core.md

@@ -1,242 +0,0 @@
-# Renee Core
-
-## Routing
-
-Routing in `Renee` is different from any web framework you are likely to have used in the past. The syntax is most familiar to Sinatra but allows
-for far more flexibility and freedom in the way that routes and actions are defined. In a Renee, routes are defined using the `path`, `var`, `query_string`, `extension`, `remainder` and request methods.
-
-**Request Methods**
-
-The bread and butter of Renee are the request verbs reminiscent of Sinatra:
-
-```ruby
-run Renee.core {
-  get    { halt "a get!"  }
-  post   { halt "a post!" }
-  put    { halt "a put!"  }
-  delete { halt "a delete!" }
-}
-```
-
-These will declare the response to "/" for each of the common request types. Notice the use of the request method to
-specify the http verb and the use of `halt` inside the block to send back the body of the response.
-
-**Path**
-
-Path is how Renee describes the basic uri path for a route:
-
-```ruby
-run Renee.core {
-  path('blog') { ... }
-}
-```
-
-All declarations inside that block will start with `/blog`. Paths can also be nested within one another:
-
-```ruby
-run Renee.core {
-  path('blog') {
-    path('foo') { get { halt "path is /blog/foo" } }
-  }
-}
-```
-
-You can also use `exact_path` for more precise path matching and/or `part` which doesn't look for leading slashes.
-
-**Query String**
-
-In addition to defining paths, you may find yourself wanting to describe the state of the query string for a request within the path:
-
-```ruby
-path 'foo' do
-  query_string 'bar' do
-    get { halt 'BAR!' }
-  end
-
-  query_string 'baz' do
-    get { halt 'BAZ!' }
-  end
-end
-```
-
-This will respond to `/foo?bar` with "BAR!" and `/foo?baz` with "BAZ!". You can also specify query_string in a variety of other ways:
-
-```ruby
-# Check key and value of query param
-query_string 'foo=bar' do
-  post { halt [200,{},'foo'] }
-end
-
-# Declare query params as a hash
-query :foo => "bar" do
-  halt 200
-end
-
-# Switch based on a query parameter
-query :foo do |var|
-  case var
-  when 'bar' then halt 200
-  when 'bar2' then halt 500
-  end
-end
-```
-
-**Variables**
-
-In Renee, you specify parameters for your request as explicit variables. Variables are declared like this:
-
-```ruby
-path('blog') {
-  var { |id| get { halt "path is /blog/#{id}" } }
-}
-```
-
-You can access the variables (passed into the request) using the local variables yielded to the block. Variables are a powerful
-way to express expected parameters for a given set of requests. You can specify variables that match a regex:
-
-```ruby
-path('blog') {
-  var(/\d+/) { |id| get { halt "path is /blog/#{id}" } }
-}
-```
-
-and even explicitly cast your variable types:
-
-```ruby
-path('blog') {
-  var :integer do |id|
-    get { halt "path is /blog/#{id} and id is an integer" }
-  end
-end
-```
-
-**Extensions**
-
-You can also use `extension` as a way to define formats:
-
-```ruby
-path '/test' do
-  extension 'html' do
-    halt 'html'
-  end
-  extension 'json' do
-    halt 'json'
-  end
-end
-```
-
-This will have `test.html` respond with 'html' and `test.json` respond with 'json'.
-
-**Remainder**
-
-In the event that no route has been matched, the `remainder` keyword makes defining the else case rather easy:
-
-```ruby
-path 'foo' do
-  path 'bar' do
-    halt "BAR!"
-  end
-
-  remainder do |rest|
-    halt "Rest was #{rest}"
-  end
-end
-```
-
-Notice this allows you to handle the cases within a particular route scope and manage them based on the "rest" of the uri yielded in the `remainder` block. You
-can handle different remainders in all the different path blocks.
-
-**Named Routes**
-
-Once you have defined your routes, you can then "register" a particular path mapping that to a symbol. This is useful for referencing routes without
-having to specify the entire path:
-
-```ruby
-run Renee.core {
-  register(:test, '/test/time')
-  register(:test_var, '/test/:id')
-}
-```
-
-You can then access these using the `path` method in a route or template:
-
-```ruby
-path(:test) # => '/test/time'
-path(:test_var, :id => 123) # => '/test/123'
-```
-
-Using named routes makes referencing and modifying routes within an application much simpler to manage.
-
-## Responding
-
-Responding to a request within a route can be managed with the `respond`, `halt`, `redirect` commands:
-
-**Respond**
-
-The `respond` command makes returning a rack response very explicit, you can respond as if you were constructing a Rack::Response
-
-```ruby
-run Renee {
-  get { respond!("hello!", 403, "foo" => "bar") }
-}
-```
-
-or use the block DSL for convenience:
-
-```ruby
-run Renee {
-  get { respond! { status 403; headers :foo => "bar"; body "hello!" } }
-}
-```
-
-**Halt**
-
-Halting is the easiest way to render data within a route:
-
-```ruby
-run Renee.core {
-  get { halt 'easy' }
-}
-```
-
-This will return a 200 status code and 'easy' as the body. You can also specify status code and header explicitly in the halt response:
-
-```ruby
-get { halt [200, {}, 'body'] }
-```
-
-This will set the status code to 200, pass no headers and return 'body'. You can also use several variations of halt:
-
-```ruby
-# Return just status code
-halt 200
-
-# Return status with symbol
-halt :not_found
-
-# Return 200 with body
-halt "hello!"
-
-# Return 500 with body
-halt 500, "hello!"
-```
-
-Halt is the most straightforward way to control the response for a request.
-
-**Redirect**
-
-A redirect is a common action within a web route and can be achieved with the convenience method `redirect` command:
-
-```ruby
-get {
-  halt redirect('/hello')
-}
-```
-
-You can also specify the status code for the redirect:
-
-```ruby
-get {
-  halt redirect('/hello', 303)
-}
-```

data/README-renee-render.md

@@ -1,38 +0,0 @@
-# Renee Render
-
-Rendering templates in Renee should be familiar and intuitive using the `render` command:
-
-```ruby
-run Renee.core {
- path('blog') do
-   get { render! "blogs/index", :haml }
- end
-}
-```
-
-This above is the standard render syntax, specifying the engine followed by the template. You can also render without specifying an engine:
-
-```ruby
-path('blog') do
-  get { render! "blogs/index" }
-end
-```
-
-This will do a lookup in the views path to find the appropriately named template. You can also pass locals and layout options as you would expect:
-
-```ruby
-path('blog') do
-  get { render! "blogs/index", :locals => { :foo => "bar" }, :layout => :bar }
-end
-```
-
-This will render the "blogs/index.erb" file if it exists, passing the 'foo' local variable
-and wrapping the result in the 'bar.erb' layout file. You can also render without returning the response by using:
-
-```ruby
-path('blog') do
-  get { render "blogs/index" }
-end
-```
-
-This allows you to render the content as a string without immediately responding.

data/README-renee-session.md

@@ -1,3 +0,0 @@
-# Renee Session
-
-Defines methods for accessing the session.

data/README-renee-url-generation.md

@@ -1,3 +0,0 @@
-# Renee URL Generation
-
-The URL generation is pretty nifty.

data/lib/renee/core.rb

@@ -1,98 +0,0 @@
-require 'rack'
-
-require 'renee/version'
-require 'renee/core/matcher'
-require 'renee/core/chaining'
-require 'renee/core/response'
-require 'renee/core/exceptions'
-require 'renee/core/rack_interaction'
-require 'renee/core/request_context'
-require 'renee/core/transform'
-require 'renee/core/routing'
-require 'renee/core/responding'
-require 'renee/core/env_accessors'
-require 'renee/core/plugins'
-
-# Top-level Renee constant
-module Renee
-  # @example
-  #     Renee.core { path('/hello') { halt :ok } }
-  def self.core(&blk)
-    cls = Class.new(Renee::Core)
-    cls.app(&blk) if blk
-    cls
-  end
-
-  # The top-level class for creating core application.
-  # For convience you can also used a method named #Renee
-  # for decalaring new instances.
-  class Core
-    # Current version of Renee::Core
-    VERSION = Renee::VERSION
-
-    # Error raised if routing fails. Use #continue_routing to continue routing.
-    NotMatchedError = Class.new(RuntimeError)
-
-    # Class methods that are included in new instances of {Core} 
-    module ClassMethods
-      include Plugins
-
-      # The application block used to create your application.
-      attr_reader :application_block
-
-      # Provides a rack interface compliant call method. This method creates a new instance of your class and calls
-      # #call on it.
-      def call(env)
-        new.call(env)
-      end
-
-      # Allows you to set the #application_block on your class.
-      # @yield The application block
-      def app(&app)
-        @application_block = app
-        setup do
-          register_variable_type :integer, IntegerMatcher
-          register_variable_type :int, :integer
-        end
-      end
-
-      # Runs class methods on your application.
-      def setup(&blk)
-        instance_eval(&blk)
-        self
-      end
-
-      # The currently available variable types you've defined.
-      def variable_types
-        @variable_types ||= {}
-      end
-
-      # Registers a new variable type for use within {Renee::Core::Routing#variable} and others.
-      # @param [Symbol] name The name of the variable.
-      # @param [Regexp] matcher A regexp describing what part of an arbitrary string to capture.
-      # @return [Renee::Core::Matcher] A matcher
-      def register_variable_type(name, matcher)
-        matcher = case matcher
-        when Matcher then matcher
-        when Array   then Matcher.new(matcher.map{|m| variable_types[m]})
-        when Symbol  then variable_types[matcher]
-        else              Matcher.new(matcher)
-        end
-        matcher.name = name
-        variable_types[name] = matcher
-      end
-    end
-
-    include Chaining
-    include RequestContext
-    include Routing
-    include Responding
-    include RackInteraction
-    include Transform
-    include EnvAccessors
-
-    class << self
-      include ClassMethods
-    end
-  end
-end

data/lib/renee/core/chaining.rb

@@ -1,66 +0,0 @@
-module Renee
-  class Core
-    # Module for creating chainable methods. To use this within your own modules, first `include Chaining`, then,
-    # mark methods you want to be available with `chain_method :method_name`.
-    # @example
-    #    module MoreRoutingMethods
-    #      include Chaining
-    #      def other_routing_method
-    #        # ..
-    #      end
-    #      chain_method :other_routing_method
-    #
-    module Chaining
-      # @private
-      class ChainingProxy
-        def initialize(target, m, args = nil)
-          @target, @calls = target, []
-          @calls << [m, args]
-        end
-
-        def method_missing(m, *args, &blk)
-          @calls << [m, args]
-          if blk.nil? && @target.class.respond_to?(:chainable?) && @target.class.chainable?(m)
-            self
-          else
-            inner_args = []
-            ret = nil
-            callback = proc do |*callback_args|
-              inner_args.concat(callback_args)
-              if @calls.size == 0
-                ret = blk.call(*inner_args) if blk
-              else
-                call = @calls.shift
-                ret = call.at(1) ? @target.send(call.at(0), *call.at(1), &callback) : @target.send(call.at(0), &callback) 
-              end
-            end
-            ret = callback.call
-            ret
-          end
-        end
-      end
-
-      # @private
-      module ClassMethods
-        def chainable?(m)
-          method_defined?(:"#{m}_chainable")
-        end
-
-        def chainable(*methods)
-          methods.each do |m|
-            define_method(:"#{m}_chainable") { }
-          end
-        end
-
-      end
-
-      def create_chain_proxy(method_name, *args)
-        ChainingProxy.new(self, method_name, args)
-      end
-
-      def self.included(o)
-        o.extend(ClassMethods)
-      end
-    end
-  end
-end