roger 1.1.3 → 1.2.1

data/lib/roger/server.rb

@@ -1,24 +1,24 @@
-require 'rack'
+require "rack"
 require File.dirname(__FILE__) + "/template"
 require File.dirname(__FILE__) + "/rack/roger"
 
-require 'webrick'
-require 'webrick/https'
+require "webrick"
+require "webrick/https"
 
 module Roger
+  # The Roger webserver. Initializes a rack server.
   class Server
-
     attr_reader :server_options
 
     attr_reader :project
 
     attr_accessor :port, :handler, :host
 
-    def initialize(project, options={})
-      @stack = initialize_rack_builder
-
+    def initialize(project, options = {})
       @project = project
 
+      @stack = initialize_rack_builder
+
       @server_options = {}
 
       # Defaults
@@ -32,28 +32,28 @@ module Roger
     # Sets the options, this is a separate method as we want to override certain
     # things set in the mockupfile from the commandline
     def set_options(options)
-      self.port = options[:port] if options.has_key?(:port)
-      self.handler = options[:handler] if options.has_key?(:handler)
-      self.host = options[:host] if options.has_key?(:host)
+      self.port = options[:port] if options.key?(:port)
+      self.handler = options[:handler] if options.key?(:handler)
+      self.host = options[:host] if options.key?(:host)
     end
 
     # Use the specified Rack middleware
     #
     # @see ::Rack::Builder#use
     def use(*args, &block)
-      @stack.use *args, &block
+      @stack.use(*args, &block)
     end
 
     # Use the map handler to map endpoints to certain urls
     #
     # @see ::Rack::Builder#map
     def map(*args, &block)
-      @stack.map *args, &block
+      @stack.map(*args, &block)
     end
 
     def run!
       project.mode = :server
-      self.handler.run self.application, self.server_options do |server|
+      handler.run application, server_options do |server|
         trap(:INT) do
           ## Use thins' hard #stop! if available, otherwise just #stop
           server.respond_to?(:stop!) ? server.stop! : server.stop
@@ -63,21 +63,21 @@ module Roger
     ensure
       project.mode = nil
     end
-    alias :run :run!
+    alias_method :run, :run!
 
     def port=(p)
-      @port = self.server_options[:Port] = p
+      @port = server_options[:Port] = p
     end
 
     def host=(h)
-      @host = self.server_options[:Host] = h
+      @host = server_options[:Host] = h
     end
 
     def handler=(h)
       if h.respond_to?(:run)
         @handler = h
       else
-        @handler = self.get_handler(h)
+        @handler = get_handler(h)
       end
     end
 
@@ -87,7 +87,7 @@ module Roger
     def application
       return @app if @app
 
-      @stack.run Rack::Roger.new(self.project)
+      @stack.run Rack::Roger.new(project)
 
       @app = @stack
     end
@@ -96,7 +96,25 @@ module Roger
     #
     # @return ::Rack::Builder instance
     def initialize_rack_builder
+      roger_env = Class.new do
+        class << self
+          attr_accessor :project
+        end
+
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          env["roger.project"] = self.class.project
+          @app.call(env)
+        end
+      end
+
+      roger_env.project = project
+
       builder = ::Rack::Builder.new
+      builder.use roger_env
       builder.use ::Rack::ShowExceptions
       builder.use ::Rack::Lint
       builder.use ::Rack::ConditionalGet
@@ -108,23 +126,30 @@ module Roger
     # Get the actual handler for use in the server
     # Will always return a handler, it will try to use the fallbacks
     def get_handler(preferred_handler_name = nil)
-      servers = %w[puma mongrel thin webrick]
+      servers = %w(puma mongrel thin webrick)
       servers.unshift(preferred_handler_name) if preferred_handler_name
 
+      handler, server_name = detect_valid_handler(servers)
+
+      if preferred_handler_name && server_name != preferred_handler_name
+        puts "Handler '#{preferred_handler_name}' not found, using fallback ('#{handler.inspect}')."
+      end
+      handler
+    end
+
+    # See what handlers work
+    def detect_valid_handler(servers)
       handler = nil
-      while((server_name = servers.shift) && handler === nil) do
+      while (server_name = servers.shift) && handler.nil?
         begin
           handler = ::Rack::Handler.get(server_name)
+          return [handler, server_name]
         rescue LoadError
+          handler = nil
         rescue NameError
+          handler = nil
         end
       end
-
-      if preferred_handler_name && server_name != preferred_handler_name
-        puts "Handler '#{preferred_handler_name}' not found, using fallback ('#{handler.inspect}')."
-      end
-      handler
     end
-
   end
-end
+end

data/lib/roger/template.rb

@@ -1,56 +1,53 @@
-require 'tilt'
-require 'mime/types'
-require 'yaml'
-require 'ostruct'
+require "tilt"
+require "mime/types"
+require "yaml"
+require "ostruct"
 
 # We're enforcing Encoding to UTF-8
 Encoding.default_external = "UTF-8"
 
 module Roger
-  
+  # Roger template processing class
   class Template
-    
     # The source
     attr_accessor :source
-    
+
     # Store the frontmatter
     attr_accessor :data
-    
+
     # The actual Tilt template
     attr_accessor :template
-    
+
     # The path to the source file for this template
     attr_accessor :source_path
-    
+
     class << self
       def open(path, options = {})
-        raise "Unknown file #{path}" unless File.exist?(path)
-        self.new(File.read(path), options.update(:source_path => path))
-      end      
+        fail "Unknown file #{path}" unless File.exist?(path)
+        new(File.read(path), options.update(source_path: path))
+      end
     end
-    
-    
-    # @option options [String,Pathname] :source_path The path to the source of the template being processed
+
+    # @option options [String,Pathname] :source_path The path to
+    #   the source of the template being processed
     # @option options [String,Pathname] :layouts_path The path to where all layouts reside
-    # @option options [String,Pathname] :partials_path The path to where all partials reside    
+    # @option options [String,Pathname] :partials_path The path to where all partials reside
     def initialize(source, options = {})
       @options = options
 
       self.source_path = options[:source_path]
       self.data, self.source = extract_front_matter(source)
-      self.template = Tilt.new(self.source_path.to_s){ self.source }
-      
-      if self.data[:layout] && layout_template_path = self.find_template(self.data[:layout], :layouts_path)
-        @layout_template = Tilt.new(layout_template_path.to_s)
-      end
+      self.template = Tilt.new(source_path.to_s) { self.source }
+
+      initialize_layout
     end
-    
+
     def render(env = {})
       context = TemplateContext.new(self, env)
-      
+
       if @layout_template
-        content_for_layout = self.template.render(context, {}) # yields
-        
+        content_for_layout = template.render(context, {}) # yields
+
         @layout_template.render(context, {}) do |content_for|
           if content_for
             context._content_for_blocks[content_for]
@@ -59,26 +56,28 @@ module Roger
           end
         end
       else
-        self.template.render(context, {})
+        template.render(context, {})
       end
     end
-    
+
     def find_template(name, path_type)
-      raise(ArgumentError, "path_type must be one of :partials_path or :layouts_path") unless [:partials_path, :layouts_path].include?(path_type)
+      unless [:partials_path, :layouts_path].include?(path_type)
+        fail(ArgumentError, "path_type must be one of :partials_path or :layouts_path")
+      end
 
       return nil unless @options[path_type]
 
-      @resolvers ||= {}        
+      @resolvers ||= {}
       @resolvers[path_type] ||= Resolver.new(@options[path_type])
-      
-      @resolvers[path_type].find_template(name, :preferred_extension => self.target_extension)
+
+      @resolvers[path_type].find_template(name, preferred_extension: target_extension)
     end
 
     # Try to infer the final extension of the output file.
     def target_extension
       return @target_extension if @target_extension
 
-      if type = MIME::Types[self.target_mime_type].first
+      if type = MIME::Types[target_mime_type].first
         # Dirty little hack to enforce the use of .html instead of .htm
         if type.sub_type == "html"
           @target_extension = "html"
@@ -86,49 +85,68 @@ module Roger
           @target_extension = type.extensions.first
         end
       else
-        @target_extension = File.extname(self.source_path.to_s).sub(/^\./, "")
+        @target_extension = File.extname(source_path.to_s).sub(/^\./, "")
       end
     end
 
     def source_extension
-      parts = File.basename(File.basename(self.source_path.to_s)).split(".")
+      parts = File.basename(File.basename(source_path.to_s)).split(".")
       if parts.size > 2
         parts[-2..-1].join(".")
       else
-        File.extname(self.source_path.to_s).sub(/^\./, "")
+        File.extname(source_path.to_s).sub(/^\./, "")
       end
     end
 
     # Try to figure out the mime type based on the Tilt class and if that doesn't
     # work we try to infer the type by looking at extensions (needed for .erb)
     def target_mime_type
-      mime = self.template.class.default_mime_type
-      return mime if mime
-
-      path = File.basename(self.source_path.to_s)
-      mime = MIME::Types.type_for(path).first
-      return mime.to_s if mime
+      mime =
+        mime_type_from_template ||
+        mime_type_from_filename ||
+        mime_type_from_sub_extension
 
-      parts = File.basename(path).split(".")
-      if parts.size > 2
-        mime = MIME::Types.type_for(parts[0..-2].join(".")).first
-        return mime.to_s if mime
-      else
-        nil
-      end
+      mime.to_s if mime
     end
-    
+
     protected
 
+    def initialize_layout
+      return unless data[:layout]
+      layout_template_path = find_template(data[:layout], :layouts_path)
+
+      @layout_template = Tilt.new(layout_template_path.to_s) if layout_template_path
+    end
+
+    def mime_type_from_template
+      template.class.default_mime_type
+    end
+
+    def mime_type_from_filename
+      path = File.basename(source_path.to_s)
+      MIME::Types.type_for(path).first
+    end
+
+    # Will get mime_type from source_path extension
+    # but it will only look at the second extension so
+    # .html.erb will look at .html
+    def mime_type_from_sub_extension
+      parts = File.basename(source_path.to_s).split(".")
+      MIME::Types.type_for(parts[0..-2].join(".")).first if parts.size > 2
+    end
+
     # Get the front matter portion of the file and extract it.
     def extract_front_matter(source)
       fm_regex = /\A(---\s*\n.*?\n?)^(---\s*$\n?)/m
-      
+
       if match = source.match(fm_regex)
         source = source.sub(fm_regex, "")
 
         begin
-          data = (YAML.load(match[1]) || {}).inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+          data = (YAML.load(match[1]) || {}).inject({}) do |memo, (k, v)|
+            memo[k.to_sym] = v
+            memo
+          end
         rescue *YAML_ERRORS => e
           puts "YAML Exception: #{e.message}"
           return false
@@ -141,20 +159,21 @@ module Roger
     rescue
       [{}, source]
     end
-    
   end
-  
+
+  # The context that is passed to all templates
   class TemplateContext
     attr_accessor :_content_for_blocks
 
-    def initialize(template, env={})
+    def initialize(template, env = {})
       @_content_for_blocks = {}
-      @_template, @_env = template, env
+      @_template = template
+      @_env = env
 
       # Block counter to make sure erbtemp binding is always unique
       @block_counter = 0
     end
-    
+
     # The current Roger::Template in use
     def template
       @_template
@@ -162,9 +181,9 @@ module Roger
 
     # Access to the front-matter of the document (if any)
     def document
-      @_data ||= OpenStruct.new(self.template.data)
+      @_data ||= OpenStruct.new(template.data)
     end
-    
+
     # The current environment variables.
     def env
       @_env
@@ -186,40 +205,49 @@ module Roger
       @_content_for_blocks[block_name] = capture(&block)
     end
 
+    # rubocop:disable Lint/Eval
     def capture(&block)
-      raise ArgumentError, "content_for works only with ERB Templates" if !self.template.template.kind_of?(Tilt::ERBTemplate)
+      unless template.template.is_a?(Tilt::ERBTemplate)
+        fail ArgumentError, "content_for works only with ERB Templates"
+      end
 
       @block_counter += 1
       counter = @block_counter
 
       eval "@_erbout_tmp#{counter} = _erbout", block.binding
       eval "_erbout = \"\"", block.binding
-      t = Tilt::ERBTemplate.new(){ "<%= yield %>" }
+      t = Tilt::ERBTemplate.new { "<%= yield %>" }
       t.render(&block)
     ensure
       eval "_erbout = @_erbout_tmp#{counter}", block.binding
     end
-        
-    def partial(name, options = {}, &block)
-      if template_path = self.template.find_template(name, :partials_path)
-        partial_template = Tilt.new(template_path.to_s)
-        if block_given?
-          block_content = capture(&block)
-        else
-          block_content = ""
-        end
-        out = partial_template.render(self, options[:locals] || {}){ block_content }
 
+    def partial(name, options = {}, &block)
+      template_path = template.find_template(name, :partials_path)
+      if template_path
+        out = render_partial(template_path, options, &block)
         if block_given?
           eval "_erbout.concat(#{out.dump})", block.binding
         else
           out
         end
       else
-        raise ArgumentError, "No such partial #{name}, referenced from #{self.template.source_path}"
+        fail ArgumentError, "No such partial #{name}, referenced from #{template.source_path}"
+      end
+    end
+    # rubocop:enable Lint/Eval
+
+    protected
+
+    # Capture a block and render the partial
+    def render_partial(template_path, options, &block)
+      partial_template = Tilt.new(template_path.to_s)
+      if block_given?
+        block_content = capture(&block)
+      else
+        block_content = ""
       end
+      partial_template.render(self, options[:locals] || {}) { block_content }
     end
-    
   end
-  
 end