renee 0.3.11 → 0.4.0.pre1

data/lib/renee/core/routing.rb

@@ -0,0 +1,319 @@
+module Renee
+  class Core
+    # Collection of useful methods for routing within a {Renee::Core} app.
+    module Routing
+      include Chaining
+
+      # Allow continued routing if a routing block fails to match
+      # 
+      # @param [Boolean] val
+      #   indicate if continued routing should be allowed.
+      #
+      # @api public
+      def continue_routing
+        if block_given?
+          original_env = @env.dup
+          begin
+            yield
+          rescue NotMatchedError
+            @env = original_env
+          end
+        else
+          create_chain_proxy(:continue_routing)
+        end
+      end
+      chainable :continue_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)
+        if blk
+          p = p[1, p.size] if p[0] == ?/
+          extension_part = detected_extension ? "|\\.#{Regexp.quote(detected_extension)}" : ""
+          part(/^\/#{Regexp.quote(p)}(?=\/|$#{extension_part})/, &blk)
+        else
+          create_chain_proxy(:path, p)
+        end
+      end
+      chainable :path
+
+      # Like #path, but doesn't look for leading slashes.
+      def part(p)
+        if block_given?
+          p = /^\/?#{Regexp.quote(p)}/ if p.is_a?(String)
+          if match = env['PATH_INFO'][p]
+            with_path_part(match) { yield }
+          end
+        else
+          create_chain_proxy(:part, p)
+        end
+      end
+
+      # 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)
+        blk ? complex_variable(type, '/', 1, &blk) : create_chain_proxy(:variable, type)
+      end
+      alias_method :var, :variable
+      chainable :variable, :var
+
+      def optional_variable(type = nil, &blk)
+        blk ? complex_variable(type, '/', 0..1) { |vars| blk[vars.first] } : create_chain_proxy(:variable, type)
+      end
+      alias_method :optional, :optional_variable
+      chainable :optional, :optional_variable
+
+      # 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)
+        blk ? complex_variable(type, '/', count, &blk) : create_chain_proxy(:multi_variable, count, type)
+      end
+      alias_method :multi_var, :multi_variable
+      alias_method :mvar, :multi_variable
+      chainable :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)
+        blk ? complex_variable(type, '/', nil, &blk) : create_chain_proxy(:repeating_variable, type)
+      end
+      alias_method :glob, :repeating_variable
+      chainable :repeating_variable, :glob
+
+      # Match parts off the path as variables without a leading slash.
+      # @see #variable
+      # @api public
+      def partial_variable(type = nil, &blk)
+        blk ? complex_variable(type, nil, 1, &blk) : create_chain_proxy(:partial_variable, type)
+      end
+      alias_method :part_var, :partial_variable
+      chainable :partial_variable, :part_var
+
+      # Returns the matched extension. If no extension is present, returns `nil`.
+      #
+      # @example
+      #   halt [200, {}, path] if extension == 'html'
+      #
+      # @api public
+      def extension
+        detected_extension
+      end
+      alias_method :ext, :extension
+
+      # Match no extension.
+      #
+      # @example
+      #   no_extension { |path| halt [200, {}, path] }
+      #
+      # @api public
+      def no_extension(&blk)
+        blk.call unless detected_extension
+      end
+
+      # Match any remaining path.
+      #
+      # @example
+      #   remainder { |path| halt [200, {}, path] }
+      #
+      # @api public
+      def remainder(&blk)
+        blk ? with_path_part(env['PATH_INFO']) { |var| blk.call(var) } : create_chain_proxy(:remainder)
+      end
+      alias_method :catchall, :remainder
+      chainable :remainder, :catchall
+
+      # Respond to a GET request and yield the block.
+      #
+      # @example
+      #   get { halt [200, {}, "hello world"] }
+      #
+      # @api public
+      def get(&blk)
+        blk ? request_method('GET', &blk) : create_chain_proxy(:get)
+      end
+      chainable :get
+
+      # Respond to a POST request and yield the block.
+      #
+      # @example
+      #   post { halt [200, {}, "hello world"] }
+      #
+      # @api public
+      def post(&blk)
+        blk ? request_method('POST', &blk) : create_chain_proxy(:post)
+      end
+      chainable :post
+
+      # Respond to a PUT request and yield the block.
+      #
+      # @example
+      #   put { halt [200, {}, "hello world"] }
+      #
+      # @api public
+      def put(&blk)
+        blk ? request_method('PUT', &blk) : create_chain_proxy(:put)
+      end
+      chainable :put
+
+      # Respond to a DELETE request and yield the block.
+      #
+      # @example
+      #   delete { halt [200, {}, "hello world"] }
+      #
+      # @api public
+      def delete(&blk)
+        blk ? request_method('DELETE', &blk) : create_chain_proxy(:delete)
+      end
+      chainable :delete
+
+      # Match only when the path is either '' or '/'.
+      #
+      # @example
+      #   complete { halt [200, {}, "hello world"] }
+      #
+      # @api public
+      def complete(&blk)
+        if blk
+          with_path_part(env['PATH_INFO']) { blk.call } if complete?
+        else
+          create_chain_proxy(:complete)
+        end
+      end
+      chainable :complete
+
+      # Test if the path has been consumed
+      #
+      # @example
+      #   if complete?
+      #     halt "Hey, the path is done"
+      #   end
+      #
+      # @api public
+      def complete?
+        (detected_extension and env['PATH_INFO'] =~ /^\/?(\.#{Regexp.quote(detected_extension)}\/?)?$/) || (detected_extension.nil? and env['PATH_INFO'] =~ /^\/?$/)
+      end
+
+      # Match only when the path is ''.
+      #
+      # @example
+      #   empty { halt [200, {}, "hello world"] }
+      #
+      # @api public
+      def empty(&blk)
+        if blk
+          if env['PATH_INFO'] == ''
+            with_path_part(env['PATH_INFO']) { blk.call }
+          end
+        else
+          create_chain_proxy(:empty)
+        end
+      end
+      chainable :empty
+
+      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)
+        script_part = env['PATH_INFO'][0, part.size]
+        env['PATH_INFO'] = env['PATH_INFO'].slice(part.size, env['PATH_INFO'].size)
+        env['SCRIPT_NAME'] += script_part
+        yield script_part
+        raise NotMatchedError
+      end
+
+      def request_method(method)
+        if env['REQUEST_METHOD'] == method && complete?
+          yield
+          raise NotMatchedError
+        end
+      end
+    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/render.rb

@@ -0,0 +1,221 @@
+require 'tilt'
+require 'callsite'
+
+require 'renee/version'
+
+# Top-level Renee constant
+module Renee
+  # This module is responsible for handling the rendering of templates
+  # using Tilt supporting all included template engines.
+  module Render
+    # Current version of Renee::Render
+    VERSION = Renee::VERSION
+
+    def self.included(o)
+      o.extend(ClassMethods)
+    end
+
+    # Class-methods included by this module.
+    module ClassMethods
+      # Gets 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
+
+      # Gets or sets the default encoding used.
+      #
+      # @param [String] encoding The encoding to use. e.g. "utf-8"
+      def default_encoding(encoding = nil)
+        encoding ? @encoding = encoding : @encoding
+      end
+
+      # Gets or sets the default layout used.
+      #
+      # @param [String] layout The layout to use. e.g. "application.haml"
+      def default_layout(*args)
+        case args.size
+        when 0 then @layout
+        when 1 then @layout = args.first
+        else        raise
+        end
+      end
+    end
+
+    ##
+    # Exception responsible for when an expected template does not exist.
+    #
+    class TemplateNotFound < RuntimeError; end
+
+    # Same as render but automatically halts.
+    # @param  (see #render)
+    # @return (see #render)
+    # @see #render
+    def render!(file, engine = nil, options = nil, &blk)
+      halt render(file, engine, options, &blk)
+    end
+
+    # Same as inline but automatically halts.
+    # @param  (see #inline)
+    # @return (see #inline)
+    # @see #inline
+    def inline!(data, engine, options = {}, &blk)
+      options[:_caller] = Callsite.parse(caller.first)
+      halt inline(data, engine, options, &blk)
+    end
+
+    ##
+    # Renders a file given the engine and the content.
+    #
+    # @param [String] file The path to the file to render
+    # @param [Symbol] engine The name of the engine to use to render the content. If this isn't specified
+    # it will be detected based on the extension of the file.
+    # @param [Hash] options The options to pass in for rendering.
+    #
+    # @return [String] The result of rendering the data with specified engine.
+    #
+    # @example
+    #  render "index", :haml   # => "<p>test</p>"
+    #  render "index"          # => "<p>test</p>"
+    #
+    # @api public
+    #
+    def render(file, engine = nil, options = nil, &block)
+      options, engine = engine, nil if engine.is_a?(Hash)
+      render_setup(engine, options, block) do |view_options, views|
+        template_cache.fetch(engine, file, view_options) do
+          file_path, found_engine = find_template(views, file, engine)
+          template = Tilt[found_engine]
+          raise TemplateNotFound, "Template engine not found: #{found_engine.inspect}" unless template
+          raise TemplateNotFound, "Template #{file.inspect} (with engine #{engine.inspect}) not found in #{views.inspect}!" unless file_path
+          # TODO suppress errors for layouts?
+          template.new(file_path, 1, view_options)
+        end
+      end
+    end # render
+
+    ##
+    # Renders a string given the engine and the content.
+    #
+    # @param [String] data The string data to render.
+    # @param [Symbol] engine The name of the engine to use to render the content. If this isn't specified
+    # it will be detected based on the extension of the file.
+    # @param [Hash] options The options to pass in for rendering.
+    #
+    # @return [String] The result of rendering the data with specified engine.
+    #
+    # @example
+    #  inline "%p test", :haml # => "<p>test</p>"
+    #
+    # @api public
+    #
+    def inline(data, engine, options = nil, &block)
+      options, engine = engine, nil if engine.is_a?(Hash)
+      call_data = options && options.delete(:_caller) || Callsite.parse(caller.first)
+      render_setup(engine, options, block) do |view_options, views|
+        body = data.is_a?(Proc) ? data : Proc.new { data }
+        template = Tilt[engine]
+        raise "Template engine not found: #{engine}" if template.nil?
+        template.new(call_data.filename, call_data.line, view_options, &body)
+      end
+    end
+
+    ##
+    # Render a partials with collections support
+    #
+    # @return [String] The html generated from this partial.
+    #
+    # @example
+    #   partial 'photo/item', :object => @photo
+    #   partial 'photo/item', :collection => @photos
+    #   partial 'photo/item', :locals => { :foo => :bar }
+    #
+    def partial(template, options={})
+      options = { :locals => {}, :layout => false }.merge(options)
+      path            = template.to_s.split(File::SEPARATOR)
+      object_name     = path[-1].to_sym
+      path[-1]        = "_#{path[-1]}"
+      template_path   = File.join(path).to_sym
+      raise 'Partial collection specified but is nil' if options.has_key?(:collection) && options[:collection].nil?
+      if collection = options.delete(:collection)
+        options.delete(:object)
+        counter = 0
+        collection.map { |member|
+          counter += 1
+          options[:locals].merge!(object_name => member, "#{object_name}_counter".to_sym => counter)
+          render(template_path, options.dup)
+        }.join("\n")
+      else
+        if member = options.delete(:object)
+          options[:locals].merge!(object_name => member)
+        end
+        render(template_path, options.dup)
+      end
+    end
+
+    private
+
+
+    def render_setup(engine, options, block)
+      options                    ||= {}
+      options[:outvar]           ||= '@_out_buf'
+      options[:default_encoding] ||= self.class.default_encoding || options[:encoding] || "utf-8"
+
+      locals         = options.delete(:locals) || {}
+      views          = options.delete(:views)  || self.class.views_path || "./views"
+      layout         = options.key?(:layout) ? options[:layout] : self.class.default_layout
+      layout_engine  = options.delete(:layout_engine)
+      # TODO suppress template errors for layouts?
+      # TODO allow content_type to be set with an option to render?
+      scope          = options.delete(:scope) || self
+
+      # TODO default layout file convention?
+      template       = yield(options, views)
+      output         = template.render(scope, locals, &block)
+
+      if layout # render layout
+        # TODO handle when layout is missing better!
+        options = options.merge(:views => views, :layout => false, :scope => scope)
+        render(layout, layout_engine, options.merge(:locals => locals)) { output }
+      else
+        output
+      end
+    end
+
+    ##
+    # Searches view paths for template based on data and engine with rendering options.
+    # Supports finding a template without an engine.
+    #
+    # @param [String] views The view paths
+    # @param [String] name The name of the template
+    # @param [Symbol] engine The engine to use for rendering.
+    #
+    # @return [<String, Symbol>] An array of the file path and the engine.
+    #
+    # @example
+    #  find_template("./views", "index", :erb) => ["path/to/index.erb", :erb]
+    #  find_template("./views", "foo")         => ["path/to/index.haml", :haml]
+    #
+    # @api private
+    #
+    def find_template(views, name, engine=nil)
+      lookup_ext = (engine || File.extname(name.to_s)[1..-1] || "*").to_s
+      base_name = name.to_s.chomp(".#{lookup_ext}")
+      file_path = Dir[File.expand_path("#{base_name}.#{lookup_ext}", views)].first
+      engine ||= File.extname(file_path)[1..-1].to_sym if file_path
+      [file_path, engine]
+    end # find_template
+
+    # Maintain Tilt::Cache of the templates.
+    def template_cache
+      @template_cache ||= Tilt::Cache.new
+    end
+  end
+end