renee-core 0.2.0 → 0.3.0

data/lib/{renee-core → renee_core}/response.rb

@@ -1,4 +1,4 @@
-class Renee
+module Renee
   class Core
     # The response object for a Renee request. Inherits from the `Rack#Response` object.
     class Response < Rack::Response
@@ -75,4 +75,4 @@ class Renee
       end
     end
   end
-end
+end

data/lib/renee_core/routing.rb

@@ -0,0 +1,322 @@
+module Renee
+  class Core
+    # Collection of useful methods for routing within a {Renee::Core} app.
+    module Routing
+      include Chaining
+
+      # Match a path to respond to.
+      #
+      # @param [String] p
+      #   path to match.
+      # @param [Proc] blk
+      #   block to yield
+      #
+      # @example
+      #   path('/')    { ... } #=> '/'
+      #   path('test') { ... } #=> '/test'
+      #
+      #   path 'foo' do
+      #     path('bar') { ... } #=> '/foo/bar'
+      #   end
+      #
+      # @api public
+      def path(p, &blk)
+        p = p[1, p.size] if p[0] == ?/
+        extension_part = detected_extension ? "|\\.#{Regexp.quote(detected_extension)}" : ""
+        part(/^\/#{Regexp.quote(p)}(?=\/|$#{extension_part})/, &blk)
+      end
+      chain_method :path
+
+      # Like #path, but requires the entire path to be consumed.
+      # @see #path
+      def whole_path(p, &blk)
+        path(p) { complete(&blk) }
+      end
+      chain_method :whole_path
+
+      # Like #path, but doesn't look for leading slashes.
+      def part(p, &blk)
+        p = /^\/?#{Regexp.quote(p)}/ if p.is_a?(String)
+        if match = env['PATH_INFO'][p]
+          with_path_part(match) { blk.call }
+        end
+      end
+      chain_method :part
+
+      # Match parts off the path as variables. The parts matcher can conform to either a regular expression, or be an Integer, or
+      # simply a String.
+      # @param[Object] type the type of object to match for. If you supply Integer, this will only match integers in addition to casting your variable for you.
+      # @param[Object] default the default value to use if your param cannot be successfully matched.
+      #
+      # @example
+      #   path '/' do
+      #     variable { |id| halt [200, {}, id] }
+      #   end
+      #   GET /hey  #=> [200, {}, 'hey']
+      #
+      # @example
+      #   path '/' do
+      #     variable(:integer) { |id| halt [200, {}, "This is a numeric id: #{id}"] }
+      #   end
+      #   GET /123  #=> [200, {}, 'This is a numeric id: 123']
+      #
+      # @example
+      #   path '/test' do
+      #     variable { |foo, bar| halt [200, {}, "#{foo}-#{bar}"] }
+      #   end
+      #   GET /test/hey/there  #=> [200, {}, 'hey-there']
+      #
+      # @api public
+      def variable(type = nil, &blk)
+        complex_variable(type, '/', 1, &blk)
+      end
+      alias_method :var, :variable
+      chain_method :variable, :var
+
+      # Same as variable except you can match multiple variables with the same type.
+      # @param [Range, Integer] count The number of parameters to capture.
+      # @param [Symbol] type The type to use for match.
+      def multi_variable(count, type = nil, &blk)
+        complex_variable(type, '/', count, &blk)
+      end
+      alias_method :multi_var, :multi_variable
+      alias_method :mvar, :multi_variable
+      chain_method :multi_variable, :multi_var, :mvar
+
+      # Same as variable except it matches indefinitely.
+      # @param [Symbol] type The type to use for match.
+      def repeating_variable(type = nil, &blk)
+        complex_variable(type, '/', nil, &blk)
+      end
+      alias_method :glob, :repeating_variable
+      chain_method :repeating_variable, :glob
+
+      # Match parts off the path as variables without a leading slash.
+      # @see #variable
+      # @api public
+      def partial_variable(type = nil, &blk)
+        complex_variable(type, nil, 1, &blk)
+      end
+      alias_method :part_var, :partial_variable
+      chain_method :partial_variable, :part_var
+
+      # Match an extension.
+      #
+      # @example
+      #   extension('html') { |path| halt [200, {}, path] }
+      #
+      # @api public
+      def extension(ext, &blk)
+        if detected_extension && match = detected_extension[ext]
+          if match == detected_extension
+            (ext_match = env['PATH_INFO'][/\/?\.#{match}/]) ?
+              with_path_part(ext_match, &blk) : blk.call
+          end
+        end
+      end
+      alias_method :ext, :extension
+      chain_method :extension, :ext
+
+      # Match no extension.
+      #
+      # @example
+      #   no_extension { |path| halt [200, {}, path] }
+      #
+      # @api public
+      def no_extension(&blk)
+        blk.call if detected_extension.nil?
+      end
+      chain_method :no_extension
+
+      # Match any remaining path.
+      #
+      # @example
+      #   remainder { |path| halt [200, {}, path] }
+      #
+      # @api public
+      def remainder(&blk)
+        with_path_part(env['PATH_INFO']) { |var| blk.call(var) }
+      end
+      alias_method :catchall, :remainder
+      chain_method :remainder, :catchall
+
+      # Respond to a GET request and yield the block.
+      #
+      # @example
+      #   get { halt [200, {}, "hello world"] }
+      #
+      # @api public
+      def get(path = nil, &blk)
+        request_method('GET', path, &blk)
+      end
+      chain_method :get
+
+      # Respond to a POST request and yield the block.
+      #
+      # @example
+      #   post { halt [200, {}, "hello world"] }
+      #
+      # @api public
+      def post(path = nil, &blk)
+        request_method('POST', path, &blk)
+      end
+      chain_method :post
+
+      # Respond to a PUT request and yield the block.
+      #
+      # @example
+      #   put { halt [200, {}, "hello world"] }
+      #
+      # @api public
+      def put(path = nil, &blk)
+        request_method('PUT', path, &blk)
+      end
+      chain_method :put
+
+      # Respond to a DELETE request and yield the block.
+      #
+      # @example
+      #   delete { halt [200, {}, "hello world"] }
+      #
+      # @api public
+      def delete(path = nil, &blk)
+        request_method('DELETE', path, &blk)
+      end
+      chain_method :delete
+
+      # Match only when the path is either '' or '/'.
+      #
+      # @example
+      #   complete { halt [200, {}, "hello world"] }
+      #
+      # @api public
+      def complete(&blk)
+        if env['PATH_INFO'] == '/' or env['PATH_INFO'] == ''
+          with_path_part(env['PATH_INFO']) { blk.call }
+        end
+      end
+      chain_method :complete
+
+      # Match only when the path is ''.
+      #
+      # @example
+      #   empty { halt [200, {}, "hello world"] }
+      #
+      # @api public
+      def empty(&blk)
+        if env['PATH_INFO'] == ''
+          with_path_part(env['PATH_INFO']) { blk.call }
+        end
+      end
+      chain_method :empty
+
+      # Match variables within the query string.
+      #
+      # @param [Array, Hash] q
+      #   Either an array or hash of things to match query string variables. If given
+      #   an array, if you pass the values for each key as parameters to the block given.
+      #   If given a hash, then every value must be able to be matched by a registered type.
+      #
+      # @example
+      #   query(:key => :integer) { |h| halt [200, {}, "hello world #{h[:key]}"] }
+      #
+      # @example
+      #   query(:key) { |val| halt [200, {}, "key is #{val}"] }
+      #
+      # @api public
+      def query(q, &blk)
+        case q
+        when Hash  then blk.call(Hash[q.map{|(k, v)| [k, transform(v, request[k.to_s]) || return]}])
+        when Array then blk.call(*q.map{|qk| request[qk.to_s] or return })
+        else            query([q], &blk)
+        end
+      end
+      chain_method :query
+
+      # Yield block if the query string matches.
+      #
+      # @param [String] qs
+      #   The query string to match.
+      #
+      # @example
+      #   path 'test' do
+      #     query_string 'foo=bar' do
+      #       halt [200, {}, 'matched']
+      #     end
+      #   end
+      #   GET /test?foo=bar #=> 'matched'
+      #
+      # @api public
+      def query_string(qs, &blk)
+        blk.call if qs === env['QUERY_STRING']
+      end
+      chain_method :query_string
+
+      private
+      def complex_variable(type, prefix, count)
+        matcher = variable_matcher_for_type(type)
+        path = env['PATH_INFO'].dup
+        vals = []
+        var_index = 0
+        variable_matching_loop(count) do
+          path.start_with?(prefix) ? path.slice!(0, prefix.size) : break if prefix
+          if match = matcher[path]
+            path.slice!(0, match.first.size)
+            vals << match.last
+          end
+        end
+        return unless count.nil? || count === vals.size
+        with_path_part(env['PATH_INFO'][0, env['PATH_INFO'].size - path.size]) do
+          if count == 1
+            yield(vals.first)
+          else
+            yield(vals)
+          end
+        end
+      end
+
+      def variable_matching_loop(count)
+        case count
+        when Range then count.max.times { break unless yield }
+        when nil   then loop { break unless yield }
+        else            count.times { break unless yield }
+        end
+      end
+
+      def variable_matcher_for_type(type)
+        if self.class.variable_types.key?(type)
+          self.class.variable_types[type]
+        else
+          regexp = case type
+          when nil, String
+            detected_extension ?
+              /(([^\/](?!#{Regexp.quote(detected_extension)}$))+)(?=$|\/|\.#{Regexp.quote(detected_extension)})/ :
+              /([^\/]+)(?=$|\/)/
+          when Regexp
+            type
+          else
+            raise "Unexpected variable type #{type.inspect}"
+          end
+          proc do |path|
+            if match = /^#{regexp.to_s}/.match(path)
+              [match[0]]
+            end
+          end
+        end
+      end
+
+      def with_path_part(part)
+        old_path_info, old_script_name = env['PATH_INFO'], env['SCRIPT_NAME']
+        script_part, env['PATH_INFO'] = old_path_info[0, part.size], old_path_info[part.size, old_path_info.size]
+        env['SCRIPT_NAME'] += script_part
+        yield script_part
+        env['PATH_INFO'], env['SCRIPT_NAME'] = old_path_info, old_script_name
+      end
+
+      def request_method(method, path = nil, &blk)
+        path ? whole_path(path) { blk.call } : complete { blk.call } if env['REQUEST_METHOD'] == method
+      end
+      chain_method :request_method
+    end
+  end
+end

data/lib/renee_core/transform.rb

@@ -0,0 +1,18 @@
+module Renee
+  class Core
+    # Module used for transforming arbitrary values using the registerd variable types.
+    # @see #register_variable_name.
+    #
+    module Transform
+      # Transforms a value according to the rules specified by #register_variable_name.
+      # @param [Symbol] name The name of the variable type.
+      # @param [String] value The value to transform.
+      # @return The transformed value or nil.
+      def transform(type, value)
+        if self.class.variable_types.key?(type) and m = self.class.variable_types[type][value]
+          m.first == value ? m.last : nil
+        end
+      end
+    end
+  end
+end

data/lib/{renee-core → renee_core}/url_generation.rb

@@ -1,6 +1,6 @@
 require 'uri'
 
-class Renee
+module Renee
   class Core
     # URL generator for creating paths and URLs within your application.
     module URLGeneration
@@ -62,7 +62,7 @@ class Renee
         generator = url_generators[name]
         generator ? generator.url(*args) : raise("Generator for #{name} doesn't exist")
       end
-      
+    
       private
       def url_generators
         @url_generators ||= {}
@@ -105,4 +105,4 @@ class Renee
       end
     end
   end
-end
+end

data/lib/renee_core/version.rb

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

data/renee-core.gemspec

@@ -1,6 +1,6 @@
 # -*- encoding: utf-8 -*-
 $:.push File.expand_path("../lib", __FILE__)
-require "renee-core/version"
+require "renee_core/version"
 
 Gem::Specification.new do |s|
   s.name        = "renee-core"

data/test/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::InvalidEnvName) {
+      @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/include_test.rb

@@ -3,7 +3,7 @@ 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.new {
+    @app = Renee.core {
       halt :ok if respond_to?(:hi)
     }.setup {
       include Module.new { def hi; end }