renee-core 0.2.0 → 0.3.0

data/lib/renee-core/application/responding.rb

@@ -1,112 +0,0 @@
-class Renee
-  class Core
-    class Application
-      # 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)
-          Renee::Core::Response.new(body, status, header).tap { |r| r.instance_eval(&blk) if block_given? }.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              raise "Unable to render #{response.inspect}"
-          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.new { 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.new { get { redirect! '/index' } }
-        #     r.call(Rack::MockResponse("/")) # => [302, {"Location" => "/index"}, []]
-        def redirect!(path, code = 302)
-          halt redirect(path, code)
-        end
-      end
-    end
-  end
-end

data/lib/renee-core/application/routing.rb

@@ -1,319 +0,0 @@
-class Renee
-  class Core
-    class Application
-      # 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 automatically match trailing-slashes.
-        # @see #path
-        def exact_path(p, &blk)
-          p = p[1, part.size] if p[0] == ?/
-          part(/^\/#{Regexp.quote(p)}/, &blk)
-        end
-        chain_method :exact_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 has been completely consumed.
-        #
-        # @example
-        #   complete { halt [200, {}, "hello world"] }
-        #
-        # @api public
-        def complete(&blk)
-          if env['PATH_INFO'] == '' || is_index_request
-            with_path_part(env['PATH_INFO']) { blk.call }
-          end
-        end
-        chain_method :complete
-
-        # 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 settings.variable_types.key?(type)
-            settings.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
-end

data/lib/renee-core/application/transform.rb

@@ -1,20 +0,0 @@
-class Renee
-  class Core
-    class Application
-      # 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 settings.variable_types.key?(type) and m = settings.variable_types[type][value]
-            m.first == value ? m.last : nil
-          end
-        end
-      end
-    end
-  end
-end