renee 0.4.0.pre1 → 0.4.0.pre2

data/lib/renee/core/env_accessors.rb

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

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

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

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

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

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

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

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