renee-core 0.0.1

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

@@ -0,0 +1,245 @@
+class Renee
+  class Core
+    class Application
+      # Collection of useful methods for routing within a {Renee::Core} app.
+      module Routing
+        # 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] == ?/
+          part(/^\/#{Regexp.quote(p)}(\/?$)?/, &blk)
+        end
+
+        # Like #path, but requires the entire path to be consumed.
+        # @see #path
+        def whole_path(p, &blk)
+          path(p) { complete(&blk) }
+        end
+
+        # 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
+
+        # Like #path, doesn't look for leading slashes.
+        def part(p)
+          p = /\/?#{Regexp.quote(p)}/ if p.is_a?(String)
+          if match = env['PATH_INFO'][p]
+            with_path_part(match) { yield }
+          end
+        end
+
+        # Match parts off the path as variables.
+        #
+        # @example
+        #   path '/' do
+        #     variable { |id| halt [200, {}, id }
+        #   end
+        #   GET /hey  #=> [200, {}, 'hey']
+        #
+        #   path '/test' do
+        #     variable { |foo, bar| halt [200, {}, "#{foo}-#{bar}"] }
+        #   end
+        #   GET /test/hey/there  #=> [200, {}, 'hey-there']
+        #
+        # @api public
+        def variable(*args, &blk)
+          args << {} unless args.last.is_a?(Hash)
+          args.last[:prepend] = '/'
+          partial_variable(*args, &blk)
+        end
+        alias_method :var, :variable
+
+        # Match parts off the path as variables without a leading slash.
+        # @see #variable
+        # @api public
+        def partial_variable(*args, &blk)
+          opts = args.last.is_a?(Hash) ? args.pop : nil
+          type = args.first || opts && opts[:type]
+          prepend = opts && opts[:prepend] || ''
+          if type == Integer
+            complex_variable(/#{Regexp.quote(prepend)}(\d+)/, proc{|v| Integer(v)}, &blk)
+          else case type
+            when nil
+              complex_variable(/#{Regexp.quote(prepend)}([^\/]+)/, &blk)
+            when Regexp
+              complex_variable(/#{Regexp.quote(prepend)}(#{type.to_s})/, &blk)
+            else
+              raise "Unexpected variable type #{type.inspect}"
+            end
+          end
+        end
+        alias_method :part_var, :partial_variable
+
+        # Match an extension.
+        #
+        # @example
+        #   extension('html') { |path| halt [200, {}, path] }
+        #
+        # @api public
+        def extension(ext)
+          if detected_extension && match = detected_extension[ext]
+            if match == detected_extension
+              (ext_match = env['PATH_INFO'][/\/?\.#{match}/]) ?
+                with_path_part(ext_match) { yield } : yield
+            end
+          end
+        end
+        alias_method :ext, :extension
+
+        # Match no extension.
+        #
+        # @example
+        #   no_extension { |path| halt [200, {}, path] }
+        #
+        # @api public
+        def no_extension
+          yield if detected_extension.nil?
+        end
+
+        # Match any remaining path.
+        #
+        # @example
+        #   remainder { |path| halt [200, {}, path] }
+        #
+        # @api public
+        def remainder
+          with_path_part(env['PATH_INFO']) { |var| yield var }
+        end
+        alias_method :catchall, :remainder
+
+        # Respond to a GET request and yield the block.
+        #
+        # @example
+        #   get { halt [200, {}, "hello world"] }
+        #
+        # @api public
+        def get(path = nil)
+          request_method('GET', path) { yield }
+        end
+
+        # Respond to a POST request and yield the block.
+        #
+        # @example
+        #   post { halt [200, {}, "hello world"] }
+        #
+        # @api public
+        def post(path = nil)
+          request_method('POST', path) { yield }
+        end
+
+        # Respond to a PUT request and yield the block.
+        #
+        # @example
+        #   put { halt [200, {}, "hello world"] }
+        #
+        # @api public
+        def put(path = nil)
+          request_method('PUT', path) { yield }
+        end
+
+        # Respond to a DELETE request and yield the block.
+        #
+        # @example
+        #   delete { halt [200, {}, "hello world"] }
+        #
+        # @api public
+        def delete(path = nil)
+          request_method('DELETE', path) { yield }
+        end
+
+        # Match only when the path has been completely consumed.
+        #
+        # @example
+        #   delete { halt [200, {}, "hello world"] }
+        #
+        # @api public
+        def complete
+          with_path_part(env['PATH_INFO']) { yield } if env['PATH_INFO'] == '' || is_index_request
+        end
+
+        # 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 #=== match each value in the query
+        #   parameters for each key in the hash.
+        #
+        # @example
+        #   query(:key => 'value') { halt [200, {}, "hello world"] }
+        #
+        # @example
+        #   query(:key) { |val| halt [200, {}, "key is #{val}"] }
+        #
+        # @api public
+        def query(q, &blk)
+          case q
+          when Hash  then q.any? {|k,v| !(v === request[k.to_s]) } ? return : yield
+          when Array then yield *q.map{|qk| request[qk.to_s] or return }
+          else            query([q], &blk)
+          end
+        end
+
+        # 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)
+          yield if qs === env['QUERY_STRING']
+        end
+
+        private
+        def complex_variable(matcher = nil, transformer = nil, &blk)
+          warn "variable currently isn't taking any parameters" unless blk.arity > 0
+          if var_value = /^#{(matcher ? matcher.to_s : '\/([^\/]+)') * blk.arity}/.match(env['PATH_INFO'])
+            vars = var_value.to_a
+            with_path_part(vars.shift) { blk.call *vars.map{|v| transformer ? transformer[v[0, v.size]] : v[0, v.size]} }
+          end
+        end
+
+        def with_path_part(part)
+          old_path_info = env['PATH_INFO']
+          old_script_name = env['SCRIPT_NAME']
+          old_path_info[part.size, old_path_info.size - part.size]
+          script_part, remaining_part = old_path_info[0, part.size], old_path_info[part.size, old_path_info.size]
+          env['SCRIPT_NAME'] += script_part
+          env['PATH_INFO'] = remaining_part
+          yield script_part
+          env['PATH_INFO'] = old_path_info
+          env['SCRIPT_NAME'] = old_script_name
+        end
+
+        def request_method(method, path = nil)
+          path ? whole_path(path) { yield } : complete { yield } if env['REQUEST_METHOD'] == method
+        end
+      end
+    end
+  end
+end

data/lib/renee-core/application.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.dirname(__FILE__) + "/application/request_context")
+require File.expand_path(File.dirname(__FILE__) + "/application/routing")
+require File.expand_path(File.dirname(__FILE__) + "/application/responding")
+require File.expand_path(File.dirname(__FILE__) + "/application/rack_interaction")
+
+class Renee
+  class Core
+    # This is the main class used to do the respond to requests. {Routing} provides route helpers.
+    # {RequestContext} adds the RequestContext#call method to respond to Rack applications.
+    # {Responding} defines the method Responding#halt which stops processing within a {Renee::Application}.
+    # It also has methods to interpret arguments to #halt and redirection response helpers.
+    # {RackInteraction} adds methods for interacting with Rack.
+    class Application
+      include RequestContext
+      include Routing
+      include Responding
+      include RackInteraction
+
+      attr_reader :application_block, :settings
+
+      # @param [Proc] application_block The block that will be #instance_eval'd on each invocation to #call
+      def initialize(settings, &application_block)
+        @settings = settings
+        @application_block = application_block
+      end
+    end
+  end
+end

data/lib/renee-core/response.rb

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

data/lib/renee-core/settings.rb

@@ -0,0 +1,34 @@
+class Renee
+  class Core
+    ##
+    # Stores configuration settings for a particular Renee application.
+    # Powers the Renee setup block which is instance eval'ed into this object.
+    #
+    # @example
+    #  Renee::Core.new { ... }.setup { views_path "./views" }
+    #
+    class Settings
+      attr_reader :includes
+      def initialize
+        @includes = []
+      end
+
+      # Get or sets the views_path for an application.
+      #
+      # @param [String] path The path to the view files.
+      #
+      # @example
+      #  views_path("./views") => nil
+      #  views_path => "./views"
+      #
+      # @api public
+      def views_path(path = nil)
+        path ? @views_path = path : @views_path
+      end
+
+      def include(mod)
+        includes << mod
+      end
+    end
+  end
+end

data/lib/renee-core/url_generation.rb

@@ -0,0 +1,109 @@
+require 'uri'
+
+class 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
+
+      # Manages generating paths and urls for a given name.
+      # @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

@@ -0,0 +1,6 @@
+class Renee
+  class Core
+    # The version for the renee-core gem.
+    VERSION = "0.0.1"
+  end
+end

data/lib/renee-core.rb

@@ -0,0 +1,64 @@
+require 'rack'
+require 'renee-core/version'
+require 'renee-core/settings'
+require 'renee-core/response'
+require 'renee-core/application'
+require 'renee-core/url_generation'
+
+# Renee top-level constant
+class Renee
+  # The top-level class for creating core application.
+  # For convience you can also used a method named #Renee
+  # for decalaring new instances.
+  #
+  # @example
+  #     Renee::Core.new { path('/hello') { halt :ok } }
+  #
+  class Core
+    include URLGeneration
+
+    attr_reader :application_block, :settings
+
+    # @param [Proc] application_block The block of code that will be executed on each invocation of call #call.
+    #                                 Each time #call is called, a new instance of {Renee::Core::Application} will
+    #                                 be created. The block given will be #instance_eval 'd within
+    #                                 the context of that new instance.
+    #
+    def initialize(&application_block)
+      @application_block = application_block
+      @settings = Settings.new
+    end
+
+    # This is a rack-compliant `Rack#call`.
+    #
+    # @param [Hash] env The environment hash.
+    #
+    # @return [Array] A rack compliant return.
+    #
+    # @see http://rack.rubyforge.org/doc/SPEC.html
+    #
+    def call(env)
+      Application.new(settings, &application_block).call(env)
+    end
+    alias_method :[], :call
+
+    ##
+    # Configure settings for your Renee application. Accepts a settings file path
+    # or a block containing the configuration settings.
+    #
+    # @example
+    #  Renee::Core.new { ... }.setup { views_path "./views" }
+    #
+    # @api public
+    def setup(path = nil, &blk)
+      raise "Must be either path or blk to configure settings" if path && blk
+      case path
+      when nil      then settings.instance_eval(&blk)
+      when Settings then @settings = path
+      when String   then File.exist?(path) ? settings.instance_eval(File.read(path), path, 1) : raise("The settings file #{path} does not exist")
+      else               raise "Could not setup with #{path.inspect}"
+      end
+      self
+    end
+  end
+end

data/renee-core.gemspec

@@ -0,0 +1,26 @@
+# -*- 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    = ""
+  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', "~> 1.0.10"
+  s.add_development_dependency "rack-test", ">= 0.5.0"
+  s.add_development_dependency "rake", "0.8.7"
+end