renee-core 0.3.11 → 0.4.0.pre1

data/.yardopts

@@ -1,6 +0,0 @@
---output-dir ../../renee-site/public/doc/core
---readme README.md
---no-private
---title Renee Core
---markup markdown
-'lib/**/*.rb'

data/README.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/Rakefile

@@ -1,13 +0,0 @@
-require 'rake/testtask'
-require 'yard'
-
-Rake::TestTask.new do |t|
-  t.libs.push "lib"
-  t.test_files = FileList[File.expand_path('../test/**/*_test.rb', __FILE__)]
-  t.verbose = true
-end
-
-desc "Generate documentation for the Padrino framework"
-task :doc do
-  YARD::CLI::Yardoc.new.run
-end

data/lib/renee_core/request_context.rb

@@ -1,25 +0,0 @@
-module Renee
-  class Core
-    # This module deals with the Rack#call compilance. It defines #call and also defines several critical methods
-    # used by interaction by other application modules.
-    module RequestContext
-      attr_reader :env, :request, :detected_extension
-
-      # Provides a rack interface compliant call method.
-      # @param[Hash] env The rack environment.
-      def call(env)
-        @env, @request = env, Rack::Request.new(env)
-        @detected_extension = env['PATH_INFO'][/\.([^\.\/]+)$/, 1]
-        # TODO clear template cache in development? `template_cache.clear`
-        catch(:halt) do
-          begin
-            instance_eval(&self.class.application_block)
-          rescue ClientError => e
-            e.response ? instance_eval(&e.response) : halt("There was an error with your request", 400)
-          end
-          Renee::Core::Response.new("Not found", 404).finish
-        end
-      end # call
-    end
-  end
-end

data/lib/renee_core/url_generation.rb

@@ -1,108 +0,0 @@
-require 'uri'
-
-module Renee
-  class Core
-    # URL generator for creating paths and URLs within your application.
-    module URLGeneration
-
-      # Registers new paths for generation.
-      # @param [Symbol] name The name of the path
-      # @param [String] pattern The pattern used for generation.
-      # @param [Hash, nil] defaults Any default values used for generation.
-      #
-      # @example
-      #     renee.register(:path, "/my/:var/path")
-      #     renee.path(:path, 123) # => "/my/123/path"
-      #     renee.path(:path, :var => 'hey you') # => "/my/hey%20you/path"
-      def register(name, pattern, defaults = nil)
-        url_generators[name] = Generator.new("#{@generation_prefix}#{pattern}", defaults_for_generation(defaults))
-      end
-
-      # Allows the creation of generation contexts.
-      # @param [String] prefix The prefix to add to subsequent calls to #register.
-      # @param [Hash, nil] defaults The defaults to add to subsequent calls to #register.
-      # @see #register
-      #
-      # @example
-      #     renee.prefix("/prefix") {
-      #       renee.register(:prefix_path, "/path") # would register /prefix/path
-      #     }
-      def prefix(prefix, defaults = nil, &blk)
-        generator = self
-        subgenerator = Class.new {
-          include URLGeneration
-          define_method(:url_generators) { generator.send(:url_generators) }
-        }.new
-        subgenerator.instance_variable_set(:@generation_prefix, "#{@generation_prefix}#{prefix}")
-        subgenerator.instance_variable_set(:@generation_defaults, defaults_for_generation(defaults))
-        if block_given?
-          old_prefix, old_defaults = @generation_prefix, @generation_defaults
-          @generation_prefix, @generation_defaults = "#{@generation_prefix}#{prefix}", defaults_for_generation(defaults)
-          subgenerator.instance_eval(&blk)
-          @generation_prefix, @generation_defaults = old_prefix, old_defaults
-        end
-        subgenerator
-      end
-
-      # Generates a path for a given name.
-      # @param [Symbol] name The name of the path
-      # @param [Object] args The values used to generate the path. Can be named with using :name => "value" or supplied
-      #                   in the order for which the variables were decalared in #register.
-      #
-      # @see #register
-      def path(name, *args)
-        generator = url_generators[name]
-        generator ? generator.path(*args) : raise("Generator for #{name} doesn't exist")
-      end
-
-      # Generates a url for a given name.
-      # @param (see #path)
-      # @see #path
-      def url(name, *args)
-        generator = url_generators[name]
-        generator ? generator.url(*args) : raise("Generator for #{name} doesn't exist")
-      end
-    
-      private
-      def url_generators
-        @url_generators ||= {}
-      end
-
-      def defaults_for_generation(defaults)
-        @generation_defaults && defaults ? @generation_defaults.merge(defaults) : (defaults || @generation_defaults)
-      end
-
-      # @private
-      class Generator
-        attr_reader :defaults
-
-        def initialize(template, defaults = nil)
-          @defaults = defaults
-          parsed_template = URI.parse(template)
-          @host = parsed_template.host
-          @template = parsed_template.path
-          @scheme = parsed_template.scheme
-          port = parsed_template.port
-          if !port.nil? and (@scheme.nil? or @scheme == "http" && port != '80' or @scheme == "https" && port != '443')
-            @port_part = ":#{port}"
-          end
-        end
-
-        def path(*args)
-          opts = args.last.is_a?(Hash) ? args.pop : nil
-          opts = opts ? defaults.merge(opts) : defaults.dup if defaults
-          path = @template.gsub(/:([a-zA-Z0-9_]+)/) { |name|
-            name = name[1, name.size - 1].to_sym
-            (opts && opts.delete(name)) || (defaults && defaults[name]) || args.shift || raise("variable #{name.inspect} not found")
-          }
-          URI.encode(opts.nil? || opts.empty? ? path : "#{path}?#{Rack::Utils.build_query(opts)}")
-        end
-
-        def url(*args)
-          raise "This URL cannot be generated as no host has been defined." if @host.nil?
-          "#{@scheme}://#{@host}#{@port_part}#{path(*args)}"
-        end
-      end
-    end
-  end
-end

data/lib/renee_core/version.rb

@@ -1,6 +0,0 @@
-module Renee
-  class Core
-    # The current version of Renee::Core
-    VERSION = "0.3.11"
-  end
-end

data/renee-core.gemspec

@@ -1,26 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "renee_core/version"
-
-Gem::Specification.new do |s|
-  s.name        = "renee-core"
-  s.version     = Renee::Core::VERSION
-  s.authors     = ["Josh Hull", "Nathan Esquenazi", "Arthur Chiu"]
-  s.email       = ["joshbuddy@gmail.com", "nesquena@gmail.com", "mr.arthur.chiu@gmail.com"]
-  s.homepage    = "http://reneerb.com"
-  s.summary     = %q{The super-friendly rack helpers}
-  s.description = %q{The super-friendly rack helpers.}
-
-  s.rubyforge_project = "renee"
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-
-  s.add_runtime_dependency 'rack', "~> 1.3.0"
-  s.add_development_dependency 'minitest', "~> 2.6.1"
-  s.add_development_dependency 'bundler'
-  s.add_development_dependency "rack-test", ">= 0.5.0"
-  s.add_development_dependency "rake", "0.8.7"
-end

data/test/url_generation_test.rb

@@ -1,66 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require File.expand_path('../test_helper', __FILE__)
-
-describe Renee::Core::URLGeneration do
-  it "should allow registration and generation of paths" do
-    r = Renee.core()
-    r.register(:test, '/test/time')
-    r.register(:test_var, '/test/:id')
-    assert_equal '/test/time', r.path(:test)
-    assert_equal '/test/123', r.path(:test_var, :id => 123)
-    assert_equal '/test/123', r.path(:test_var, 123)
-  end
-
-  it "should allow registration and generation of urls" do
-    r = Renee.core()
-    r.register(:test, 'http://localhost:8080/test/:time')
-    assert_equal 'http://localhost:8080/test/123', r.url(:test, 123)
-    assert_equal 'http://localhost:8080/test/654', r.url(:test, :time => '654')
-  end
-
-  it "should escape values when generating" do
-    r = Renee.core()
-    r.register(:test, '/:test')
-    assert_equal '/f%C3%B8%C3%B8', r.path(:test, "føø")
-  end
-
-  it "should encode extra values as query string params" do
-    r = Renee.core()
-    r.register(:test, '/:test')
-    assert_equal '/foo?bar=baz', r.path(:test, 'foo', :bar => :baz)
-    assert_equal '/foo?bar=baz', r.path(:test, :test => 'foo', :bar => :baz)
-  end
-
-  it "should allow default values" do
-    r = Renee.core()
-    r.register(:test, '/:test', :test => 'foo')
-    assert_equal '/foo', r.path(:test)
-    assert_equal '/baz', r.path(:test, :test => 'baz')
-  end
-
-  it "should include default vars as query string vars" do
-    r = Renee.core()
-    r.register(:test, '/:foo', :test => 'foo')
-    assert_equal '/foo?test=foo', r.path(:test, 'foo')
-    assert_equal '/foo?test=foo', r.path(:test, :foo => 'foo')
-  end
-
-  it "should allow #prefix calls for nesting common path parts" do
-    r = Renee.core()
-    r.prefix('/foo') do
-      r.register(:foo_bar, '/bar')
-    end
-    assert_equal '/foo/bar', r.path(:foo_bar)
-  end
-
-  it "should allow passing defaults and overriding them on a per-register basis" do
-    r = Renee.core()
-    r.prefix('/foo', :bar => 'baz') do
-      register(:foo_bar, '/bar', :bar => 'bam')
-      register(:foo_baz, '/baz')
-    end
-    assert_equal '/foo/bar?bar=bam', r.path(:foo_bar)
-    assert_equal '/foo/baz?bar=baz', r.path(:foo_baz)
-  end
-end