renee-url-generation 0.4.0.pre1

data/lib/renee/core/chaining.rb

@@ -0,0 +1,66 @@
+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

data/lib/renee/core/env_accessors.rb

@@ -0,0 +1,72 @@
+module Renee
+  class Core
+    # Defines class-level methods for creating accessors for variables in your environment.
+    module EnvAccessors
+
+      # Exception for attempting to define an env accessor cannot be written as a method name.
+      # @example
+      #   env_accessor "current.user" # raises InvalidEnvNameError
+      #   env_accessor "current.user" => :current_user # this works
+      InvalidEnvNameError = Class.new(RuntimeError)
+
+      # Class-methods included by this module.
+      module ClassMethods
+
+        # Defines getters and setters for a list of attributes. If the attributes cannot easily be expressed, use the
+        # hash-syntax for defining them.
+        # @example
+        #   env_accessor "some_value" # will define methods to read and write env['some_value']
+        #   env_accessor "current.user" => :current_user will define methods to read and write env['current.user']
+        def env_accessor(*attrs)
+          env_reader(*attrs)
+          env_writer(*attrs)
+        end
+
+        # Defines getters for a list of attributes.
+        # @see env_accessor
+        def env_reader(*attrs)
+          instance_eval do
+            env_attr_iter(*attrs) do |key, meth|
+              define_method(meth) do
+                env[key]
+              end
+            end
+          end
+        end
+
+        # Defines setters for a list of attributes.
+        # @see env_accessor
+        def env_writer(*attrs)
+          instance_eval do
+            env_attr_iter(*attrs) do |key, meth|
+              define_method("#{meth}=") do |val|
+                env[key] = val
+              end
+            end
+          end
+        end
+
+        private
+        def env_attr_iter(*attrs)
+          attrs.each do |a|
+            case a
+            when Hash
+              a.each do |k, v|
+                yield k, v
+              end
+            else
+              raise InvalidEnvNameError, "Called env attr for #{a.inspect}, to use this, call your env method like this. env_reader #{a.inspect} => #{a.to_s.gsub(/-\./, '_').to_sym.inspect}" if a.to_s[/[-\.]/]
+              yield a, a.to_sym
+            end
+          end
+        end
+      
+      end
+
+      # @private
+      def self.included(o)
+        o.extend(ClassMethods)
+      end
+    end
+  end
+end

data/lib/renee/core/exceptions.rb

@@ -0,0 +1,15 @@
+module Renee
+  class Core
+    # Used to indicate a client-error has occurred (e.g. 4xx)
+    class ClientError < StandardError
+      attr_reader :response
+
+      # @param [String] message The message for this exception.
+      # @yield The optional block to instance-eval in the case this error is raised.
+      def initialize(message, &response)
+        super(message)
+        @response = response
+      end
+    end
+  end
+end

data/lib/renee/core/matcher.rb

@@ -0,0 +1,61 @@
+module Renee
+  class Core
+    # Class used for variable matching.
+    class Matcher
+      attr_accessor :name
+
+      # @param [Regexp] matcher The regexp matcher to determine what is part of the variable.
+      def initialize(matcher)
+        @matcher = matcher
+      end
+
+      # Used to specific the error handler if the matcher doesn't match anything. By default, there is no error handler.
+      # @yield The block to be executed it fails to match.
+      def on_error(&blk)
+        @error_handler = blk
+        self
+      end
+
+      # Used to transform the value matched.
+      # @yield TODO
+      def on_transform(&blk)
+        @transform_handler = blk
+        self
+      end
+
+      # Convienence method to creating halting error handler.
+      # @param [Symbol, Integer] error_code The HTTP code to halt with.
+      # @see #interpret_response
+      def raise_on_error!(error_code = :bad_request)
+        on_error { halt error_code }
+        self
+      end
+
+      # Matcher for string
+      # @param [String] val The value to attempt to match on.
+      # @raise [ClientError] If the match fails to match and there is an error handler defined.
+      def [](val)
+        match = nil
+        case @matcher
+        when Array
+          match = nil
+          @matcher.find { |m| match = m[val] }
+        else
+          if match = /^#{@matcher.to_s}/.match(val)
+            match = [match[0]]
+            match << @transform_handler.call(match.first) if @transform_handler
+            match
+          end
+        end
+        if match
+          match
+        elsif @error_handler
+          raise ClientError.new("There was an error interpreting the value #{val.inspect} for #{name.inspect}", &@error_handler)
+        end
+      end
+    end
+
+    # Matcher for Integers
+    IntegerMatcher = Matcher.new(/\d+/).on_transform{|v| Integer(v)}
+  end
+end

data/lib/renee/core/plugins.rb

@@ -0,0 +1,31 @@
+module Renee
+  class Core
+    module Plugins
+      attr_reader :init_blocks, :before_blocks, :after_blocks
+
+      def on_init(&blk)
+        init_blocks << blk
+      end
+
+      def init_blocks
+        (@init_blocks ||= [])
+      end
+
+      def on_before(&blk)
+        before_blocks << blk
+      end
+
+      def before_blocks
+        (@before_blocks ||= [])
+      end
+
+      def on_after(&blk)
+        before_blocks << blk
+      end
+
+      def after_blocks
+        (@after_blocks ||= [])
+      end
+    end
+  end
+end

data/lib/renee/core/rack_interaction.rb

@@ -0,0 +1,50 @@
+module Renee
+  class Core
+    # A module that defines useful Rack interaction methods.
+    module RackInteraction
+      # Creates an ad-hoc Rack application within the context of a Rack::Builder.
+      # @yield The block to be used to instantiate the `Rack::Builder`.
+      #
+      # @example
+      #     get { halt build { use Rack::ContentLength; run proc { |env| Rack::Response.new("Hello!").finish } } }
+      #
+      def build(&blk)
+        run Rack::Builder.new(&blk).to_app
+      end
+
+      # Creates an ad-hoc Rack application within the context of a Rack::Builder that immediately halts when done.
+      # @param (see #build)
+      #
+      # @example
+      #     get { halt build { use Rack::ContentLength; run proc { |env| Rack::Response.new("Hello!").finish } } }
+      #
+      def build!(&blk)
+        halt build(&blk)
+      end
+
+      # Runs a rack application. You must either use `app` or `blk`.
+      # @param [#call] app The application to call.
+      # @yield [env] The block to yield to
+      #
+      #
+      # @example
+      #     get { halt run proc { |env| Renee::Core::Response.new("Hello!").finish } }
+      #
+      def run(app = nil, &blk)
+        raise "You cannot supply both a block and an app" unless app.nil? ^ blk.nil?
+        (app || blk).call(env)
+      end
+
+      # Runs a rack application and halts immediately.
+      # @param (see #run)
+      #
+      # @see #run!
+      # @example
+      #     get { run proc { |env| Renee::Core::Response.new("Hello!").finish } }
+      #
+      def run!(app = nil, &blk)
+        halt run(app, &blk)
+      end
+    end
+  end
+end

data/lib/renee/core/request_context.rb

@@ -0,0 +1,56 @@
+module Renee
+  class Core
+    module ClassMethods
+      def use(mw, *args, &blk)
+        middlewares << [mw, args, blk]
+      end
+
+      def middlewares
+        @middlewares ||= []
+      end
+    end
+
+    # 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(e)
+        initialize_plugins
+        idx = 0
+        next_app = proc do |env|
+          if idx == self.class.middlewares.size
+            @env, @request = env, Rack::Request.new(env)
+            @detected_extension = env['PATH_INFO'][/\.([^\.\/]+)$/, 1]
+            # TODO clear template cache in development? `template_cache.clear`
+            out = catch(:halt) do
+              begin
+                self.class.before_blocks.each { |b| instance_eval(&b) }
+                instance_eval(&self.class.application_block)
+              rescue ClientError => e
+                e.response ? instance_eval(&e.response) : halt("There was an error with your request", 400)
+              rescue NotMatchedError => e
+                # unmatched, continue on
+              end
+              Renee::Core::Response.new("Not found", 404).finish
+            end
+            self.class.after_blocks.each { |a| out = instance_exec(out, &a) }
+            out
+          else
+            middleware = self.class.middlewares[idx]
+            idx += 1
+            middleware[0].new(next_app, *middleware[1], &middleware[2]).call(env)
+          end
+        end
+        next_app[e]
+      end # call
+
+      def initialize_plugins
+        self.class.init_blocks.each { |init_block| self.class.class_eval(&init_block) }
+        self.class.send(:define_method, :initialize_plugins) { }
+      end
+    end
+  end
+end

data/lib/renee/core/responding.rb

@@ -0,0 +1,112 @@
+module Renee
+  class Core
+    # Collection of useful methods for responding within a {Renee::Core} app.
+    module Responding
+      # Codes used by Symbol lookup in interpret_response.
+      # @example
+      #   halt :unauthorized # would return a 401.
+      #
+      HTTP_CODES = {
+        :ok => 200,
+        :created => 201,
+        :accepted => 202,
+        :no_content => 204,
+        :no_content => 204,
+        :bad_request => 400,
+        :unauthorized => 401,
+        :payment_required => 403,
+        :not_found => 404,
+        :method_not_found => 405,
+        :not_acceptable => 406,
+        :gone => 410,
+        :error => 500,
+        :not_implemented => 501}.freeze
+
+      # Halts current processing to the top-level calling Renee application and uses that as a response.
+      # @param [Object...] response The response to use.
+      # @see #interpret_response
+      def halt(*response)
+        throw :halt, interpret_response(response.size == 1 ? response.first : response)
+      end
+
+      ##
+      # Creates a response by allowing the response header, body and status to be passed into the block.
+      #
+      # @param [Array] body The contents to return.
+      # @param [Integer] status The status code to return.
+      # @param [Hash] header The headers to return.
+      # @param [Proc] &blk The response options to specify
+      #
+      # @example
+      #  respond { status 200; body "Yay!" }
+      #  respond("Hello", 200, "foo" => "bar")
+      #
+      def respond(body=[], status=200, header={}, &blk)
+        response = Renee::Core::Response.new(body, status, header)
+        response.instance_eval(&blk) if block_given?
+        response.finish
+      end
+
+      ##
+      # Creates a response by allowing the response header, body and status to be passed into the block.
+      #
+      # @example
+      #  respond! { status 200; body "Yay!" }
+      #
+      # @param  (see #respond)
+      # @see #respond
+      def respond!(*args, &blk)
+        halt respond(*args, &blk)
+      end
+
+      # Interprets responses returns by #halt.
+      #
+      # * If it is a Symbol, it will be looked up in {HTTP_CODES}.
+      # * If it is a Symbol, it will use Rack::Response to return the value.
+      # * If it is a Symbol, it will either be used as a Rack response or as a body and status code.
+      # * If it is an Integer, it will use Rack::Response to return the status code.
+      # * Otherwise, #to_s will be called on it and it will be treated as a Symbol.
+      #
+      # @param [Object] response This can be either a Symbol, String, Array or any Object.
+      #
+      def interpret_response(response)
+        case response
+        when Array   then
+          case response.size
+          when 3 then response
+          when 2 then Renee::Core::Response.new(response[1], HTTP_CODES[response[0]] || response[0]).finish
+          else raise "I don't know how to render #{response.inspect}"
+          end
+        when String  then Renee::Core::Response.new(response).finish
+        when Integer then Renee::Core::Response.new("Status code #{response}", response).finish
+        when Symbol  then interpret_response(HTTP_CODES[response] || response.to_s)
+        when Proc    then instance_eval(&response)
+        else              response # pass through response
+        end
+      end
+
+      # Returns a rack-based response for redirection.
+      # @param [String] path The URL to redirect to.
+      # @param [Integer] code The HTTP code to use.
+      # @example
+      #     r = Renee.core { get { halt redirect '/index' } }
+      #     r.call(Rack::MockResponse("/")) # => [302, {"Location" => "/index"}, []]
+      def redirect(path, code = 302)
+        response = ::Rack::Response.new
+        response.redirect(path, code)
+        response.finish
+      end
+
+      # Halts with a rack-based response for redirection.
+      # @see #redirect
+      # @param [String] path The URL to redirect to.
+      # @param [Integer] code The HTTP code to use.
+      # @example
+      #     r = Renee.core { get { redirect! '/index' } }
+      #     r.call(Rack::MockResponse("/")) # => [302, {"Location" => "/index"}, []]
+      def redirect!(path, code = 302)
+        halt redirect(path, code)
+      end
+    end
+  end
+end

data/lib/renee/core/response.rb

@@ -0,0 +1,78 @@
+module Renee
+  class Core
+    # The response object for a Renee request. Inherits from the `Rack#Response` object.
+    class Response < Rack::Response
+      # Augment body to allow strings.
+      #
+      # @param [String] The contents for the response.
+      #
+      # @example
+      #  res.body = "Hello"
+      #
+      # @api semipublic
+      def body=(value)
+        value = value.body while Rack::Response === value
+        @body = String === value ? [value.to_str] : value
+      end
+
+      # Alias status and body methods to allow redefinition
+      alias :status_attr :status
+      alias :status_attr= :status=
+      alias :body_attr  :body
+      alias :body_attr= :body=
+
+      # Get or set the status of the response.
+      #
+      # @param [String] val The status code to return.
+      #
+      # @example
+      #  res.status 400
+      #  res.status => 400
+      #
+      # @api public
+      def status(val=nil)
+        val ? self.status_attr = val : self.status_attr
+      end
+
+      # Get or set the body of the response.
+      #
+      # @param [String] val The contents to return.
+      #
+      # @example
+      #  res.body "hello"
+      #  res.body => "hello"
+      #
+      # @api public
+      def body(val=nil)
+        val ? self.body_attr = val : self.body_attr
+      end
+
+      # Get or set the headers of the response.
+      #
+      # @param [Hash] attrs The contents to return.
+      #
+      # @example
+      #   res.headers :foo => "bar"
+      #   res.headers => { :foo => "bar" }
+      #
+      # @api public
+      def headers(attrs={})
+        attrs ? attrs.each { |k, v| self[k.to_s] = v } : self.header
+      end
+
+      # Finishs the response based on the accumulated options.
+      # Calculates the size of the body content length and removes headers for 1xx status codes.
+      def finish
+        if status.to_i / 100 == 1
+          headers.delete "Content-Length"
+          headers.delete "Content-Type"
+        elsif Array === body and not [204, 304].include?(status.to_i)
+          headers["Content-Length"] = body.inject(0) { |l, p| l + Rack::Utils.bytesize(p) }.to_s
+        end
+
+        status, headers, result = super
+        [status, headers, result]
+      end
+    end
+  end
+end