middleman-core 3.4.1 → 4.0.0.alpha.2

data/lib/middleman-core/profiling.rb

@@ -1,22 +1,21 @@
 module Middleman
   module Profiling
-    # The profiler instance. There can only be one!
-    # rubocop:disable TrivialAccessors
-    def self.profiler=(prof)
-      @profiler = prof
-    end
-    def self.profiler
-      @profiler ||= NullProfiler.new
-    end
+    class << self
+      # The profiler instance. There can only be one!
+      attr_writer :profiler
+      def profiler
+        @profiler ||= NullProfiler.new
+      end
 
-    # Start the profiler
-    def self.start
-      profiler.start
-    end
+      # Start the profiler
+      def start
+        profiler.start
+      end
 
-    # Stop the profiler and generate a report. Make sure to call start first
-    def self.report(report_name)
-      profiler.report(report_name)
+      # Stop the profiler and generate a report. Make sure to call start first
+      def report(report_name)
+        profiler.report(report_name)
+      end
     end
 
     # A profiler that does nothing. The default.

data/lib/middleman-core/rack.rb

@@ -0,0 +1,138 @@
+require 'rack'
+require 'rack/file'
+require 'rack/lint'
+require 'rack/head'
+
+require 'middleman-core/util'
+require 'middleman-core/template_renderer'
+
+# CSSPIE HTC File
+::Rack::Mime::MIME_TYPES['.htc'] = 'text/x-component'
+
+# Let's serve all HTML as UTF-8
+::Rack::Mime::MIME_TYPES['.html'] = 'text/html; charset=utf-8'
+::Rack::Mime::MIME_TYPES['.htm'] = 'text/html; charset=utf-8'
+
+module Middleman
+  class Rack
+    extend Forwardable
+
+    def to_app
+      app = ::Rack::Builder.new
+
+      app.use ::Rack::Lint
+      app.use ::Rack::Head
+
+      @middleman.middleware.each do |middleware|
+        app.use(middleware[:class], *middleware[:options], &middleware[:block])
+      end
+
+      inner_app = self
+      app.map('/') { run inner_app }
+
+      @middleman.mappings.each do |mapping|
+        app.map(mapping[:path], &mapping[:block])
+      end
+
+      app
+    end
+
+    def_delegator :"::Middleman::Logger", :singleton, :logger
+
+    def initialize(middleman)
+      @middleman = middleman
+    end
+
+    # Rack Interface
+    #
+    # @param env Rack environment
+    def call(env)
+      # Store environment, request and response for later
+      req = ::Rack::Request.new(env)
+      res = ::Rack::Response.new
+
+      logger.debug "== Request: #{env['PATH_INFO']}"
+
+      # Catch :halt exceptions and use that response if given
+      catch(:halt) do
+        process_request(env, req, res)
+        res.status = 404
+        res.finish
+      end
+    end
+
+    # Halt the current request and return a response
+    #
+    # @param [String] response Response value
+    def halt(response)
+      throw :halt, response
+    end
+
+    # Core response method. We process the request, check with
+    # the sitemap, and return the correct file, response or status
+    # message.
+    #
+    # @param env
+    # @param [Rack::Response] res
+    def process_request(env, _, res)
+      start_time = Time.now
+
+      request_path = URI.decode(env['PATH_INFO'].dup)
+      if request_path.respond_to? :force_encoding
+        request_path.force_encoding('UTF-8')
+      end
+      request_path = ::Middleman::Util.full_path(request_path, @middleman)
+
+      # Run before callbacks
+      @middleman.run_hook :before
+
+      # Get the resource object for this path
+      resource = @middleman.sitemap.find_resource_by_destination_path(request_path.gsub(' ', '%20'))
+
+      # Return 404 if not in sitemap
+      return not_found(res, request_path) unless resource && !resource.ignored?
+
+      # If this path is a binary file, send it immediately
+      return send_file(resource, env) if resource.binary?
+
+      res['Content-Type'] = resource.content_type || 'text/plain'
+
+      begin
+        # Write out the contents of the page
+        res.write resource.render
+
+        # Valid content is a 200 status
+        res.status = 200
+      rescue Middleman::TemplateRenderer::TemplateNotFound => e
+        res.write "Error: #{e.message}"
+        res.status = 500
+      end
+
+      # End the request
+      logger.debug "== Finishing Request: #{resource.destination_path} (#{(Time.now - start_time).round(2)}s)"
+      halt res.finish
+    end
+
+    # Halt request and return 404
+    def not_found(res, path)
+      res.status = 404
+      res.write "<html><head></head><body><h1>File Not Found</h1><p>#{path}</p></body></html>"
+      res.finish
+    end
+
+    # Immediately send static file
+    def send_file(resource, env)
+      file      = ::Rack::File.new nil
+      file.path = resource.source_file[:full_path]
+      response = file.serving(env)
+      status = response[0]
+      response[1]['Content-Encoding'] = 'gzip' if %w(.svgz .gz).include?(resource.ext)
+      # Do not set Content-Type if status is 1xx, 204, 205 or 304, otherwise
+      # Rack will throw an error (500)
+      if !(100..199).include?(status) && ![204, 205, 304].include?(status)
+        response[1]['Content-Type'] = resource.content_type || 'application/octet-stream'
+      end
+      halt response
+    end
+  end
+end

data/lib/middleman-core/renderers/coffee_script.rb

@@ -4,21 +4,18 @@ require 'coffee_script'
 module Middleman
   module Renderers
     # CoffeeScript Renderer
-    module CoffeeScript
+    class CoffeeScript < ::Middleman::Extension
       # Setup extension
-      class << self
-        # Once registered
-        def registered(app)
-          # Tell Tilt to use it as well (for inline scss blocks)
-          ::Tilt.register 'coffee', DebuggingCoffeeScriptTemplate
-          ::Tilt.prefer(DebuggingCoffeeScriptTemplate)
+      def initialize(app, options={}, &block)
+        super
 
-          app.before_configuration do
-            template_extensions coffee: :js
-            DebuggingCoffeeScriptTemplate.middleman_app = self
-          end
+        # Tell Tilt to use it as well (for inline scss blocks)
+        ::Tilt.register 'coffee', DebuggingCoffeeScriptTemplate
+        ::Tilt.prefer(DebuggingCoffeeScriptTemplate)
+
+        app.before_configuration do
+          DebuggingCoffeeScriptTemplate.middleman_app = self
         end
-        alias_method :included, :registered
       end
 
       # A Template for Tilt which outputs debug messages
@@ -31,7 +28,7 @@ module Middleman
         # @param [Hash] locals
         # @return [String]
         def evaluate(context, locals, &block)
-          return super if middleman_app.build?
+          return super unless middleman_app.server?
 
           begin
             super

data/lib/middleman-core/renderers/erb.rb

@@ -1,21 +1,9 @@
 # ERb renderer
 module Middleman
   module Renderers
-    module ERb
-      # Setup extension
-      class << self
-        # once registered
-        def registered(app)
-          app.before_configuration do
-            template_extensions erb: :html
-          end
-
-          # After config
-          app.after_configuration do
-            ::Tilt.prefer(Template, :erb)
-          end
-        end
-        alias_method :included, :registered
+    class ERb < ::Middleman::Extension
+      def after_configuration
+        ::Tilt.prefer(Template, :erb)
       end
 
       class Template < ::Tilt::ErubisTemplate

data/lib/middleman-core/renderers/haml.rb

@@ -1,6 +1,9 @@
 # Require gem
 require 'haml'
 
+# Require padrino-helpers now so that we get a chance to replace their renderer with ours in Tilt.
+require 'padrino-helpers'
+
 module SafeTemplate
   def render(*)
     super.html_safe
@@ -13,25 +16,37 @@ end
 
 module Middleman
   module Renderers
+    # Haml precompiles filters before the scope is even available,
+    # thus making it impossible to pass our Middleman instance
+    # in. So we have to resort to heavy hackery :(
+    class HamlTemplate < ::Tilt::HamlTemplate
+      def prepare
+      end
+
+      def evaluate(scope, locals, &block)
+        ::Middleman::Renderers::Haml.last_haml_scope = scope
+
+        options = @options.merge(filename: eval_file, line: line)
+        @engine = ::Haml::Engine.new(data, options)
+        output = @engine.render(scope, locals, &block)
+
+        ::Middleman::Renderers::Haml.last_haml_scope = nil
+
+        output
+      end
+    end
+
     # Haml Renderer
-    module Haml
-      # Setup extension
-      class << self
-        # Once registered
-        def registered(app)
-          app.before_configuration do
-            template_extensions haml: :html
-          end
-
-          # Add haml helpers to context
-          app.send :include, ::Haml::Helpers
-
-          # Setup haml helper paths
-          app.ready do
-            init_haml_helpers
-          end
-        end
-        alias_method :included, :registered
+    class Haml < ::Middleman::Extension
+      cattr_accessor :last_haml_scope
+
+      def initialize(app, options={}, &block)
+        super
+
+        ::Tilt.prefer(::Middleman::Renderers::HamlTemplate, :haml)
+
+        # Add haml helpers to context
+        ::Middleman::TemplateContext.send :include, ::Haml::Helpers
       end
     end
   end

data/lib/middleman-core/renderers/kramdown.rb

@@ -4,8 +4,10 @@ module Middleman
   module Renderers
     # Our own Kramdown Tilt template that simply uses our custom renderer.
     class KramdownTemplate < ::Tilt::KramdownTemplate
-      def evaluate(*)
+      def evaluate(scope, *)
         @output ||= begin
+          MiddlemanKramdownHTML.scope = ::Middleman::Renderers::Haml.last_haml_scope || scope
+
           output, warnings = MiddlemanKramdownHTML.convert(@engine.root, @engine.options)
           @engine.warnings.concat(warnings)
           output
@@ -15,13 +17,13 @@ module Middleman
 
     # Custom Kramdown renderer that uses our helpers for images and links
     class MiddlemanKramdownHTML < ::Kramdown::Converter::Html
-      cattr_accessor :middleman_app
+      cattr_accessor :scope
 
       def convert_img(el, _)
         attrs = el.attr.dup
 
         link = attrs.delete('src')
-        middleman_app.image_tag(link, attrs)
+        scope.image_tag(link, attrs)
       end
 
       def convert_a(el, indent)
@@ -36,7 +38,7 @@ module Middleman
 
         attr = el.attr.dup
         link = attr.delete('href')
-        middleman_app.link_to(content, link, attr)
+        scope.link_to(content, link, attr)
       end
     end
   end

data/lib/middleman-core/renderers/less.rb

@@ -3,28 +3,22 @@ require 'less'
 module Middleman
   module Renderers
     # Sass renderer
-    module Less
-      # Setup extension
-      class << self
-        # Once registered
-        def registered(app)
-          # Default less options
-          app.config.define_setting :less, {}, 'LESS compiler options'
+    class Less < ::Middleman::Extension
+      def initialize(app, options={}, &block)
+        super
 
-          app.before_configuration do
-            template_extensions less: :css
-          end
+        # Default less options
+        app.config.define_setting :less, {}, 'LESS compiler options'
 
-          app.after_configuration do
-            ::Less.paths << File.join(source_dir, config[:css_dir])
-          end
+        # Tell Tilt to use it as well (for inline sass blocks)
+        ::Tilt.register 'less', LocalLoadingLessTemplate
+        ::Tilt.prefer(LocalLoadingLessTemplate)
+      end
 
-          # Tell Tilt to use it as well (for inline sass blocks)
-          ::Tilt.register 'less', LocalLoadingLessTemplate
-          ::Tilt.prefer(LocalLoadingLessTemplate)
+      def after_configuration
+        app.files.by_type(:source).watchers.each do |source|
+          ::Less.paths << (source.directory + app.config[:css_dir]).to_s
         end
-
-        alias_method :included, :registered
       end
 
       # A SassTemplate for Tilt which outputs debug messages

data/lib/middleman-core/renderers/liquid.rb

@@ -4,27 +4,31 @@ require 'liquid'
 module Middleman
   module Renderers
     # Liquid Renderer
-    module Liquid
-      # Setup extension
-      class << self
-        # Once registered
-        def registered(app)
-          app.before_configuration do
-            template_extensions liquid: :html
-          end
+    class Liquid < Middleman::Extension
+      # After config, setup liquid partial paths
+      def after_configuration
+        ::Liquid::Template.file_system = self
+      end
 
-          # After config, setup liquid partial paths
-          app.after_configuration do
-            ::Liquid::Template.file_system = ::Liquid::LocalFileSystem.new(source_dir)
+      # Called by Liquid to retrieve a template file
+      def read_template_file(template_path, _)
+        file = app.files.find(:source, "_#{template_path}.liquid")
+        raise ::Liquid::FileSystemError, "No such template '#{template_path}'" unless file
+        File.read(file[:full_path])
+      end
 
-            # Convert data object into a hash for liquid
-            sitemap.provides_metadata %r{\.liquid$} do
-              { locals: { data: data.to_h } }
-            end
-          end
-        end
+      # @return Array<Middleman::Sitemap::Resource>
+      Contract ResourceList => ResourceList
+      def manipulate_resource_list(resources)
+        return resources unless app.extensions[:data]
 
-        alias_method :included, :registered
+        resources.each do |resource|
+          next if resource.source_file.nil?
+          next unless resource.source_file[:relative_path].to_s =~ %r{\.liquid$}
+
+          # Convert data object into a hash for liquid
+          resource.add_metadata locals: { data: app.extensions[:data].data_store.to_h }
+        end
       end
     end
   end

data/lib/middleman-core/renderers/markdown.rb

@@ -1,61 +1,48 @@
 module Middleman
   module Renderers
     # Markdown renderer
-    module Markdown
-      # Setup extension
-      class << self
-        # Once registered
-        def registered(app)
-          # Set our preference for a markdown engine
-          app.config.define_setting :markdown_engine, :kramdown, 'Preferred markdown engine'
-          app.config.define_setting :markdown_engine_prefix, ::Tilt, 'The parent module for markdown template engines'
+    class Markdown < ::Middleman::Extension
+      # Once registered
+      def initialize(app, options={}, &block)
+        super
 
-          app.before_configuration do
-            template_extensions markdown: :html,
-                                mdown: :html,
-                                md: :html,
-                                mkd: :html,
-                                mkdn: :html
-          end
-
-          # Once configuration is parsed
-          app.after_configuration do
-            markdown_exts = %w(markdown mdown md mkd mkdn)
+        # Set our preference for a markdown engine
+        app.config.define_setting :markdown_engine, :kramdown, 'Preferred markdown engine'
+        app.config.define_setting :markdown_engine_prefix, ::Tilt, 'The parent module for markdown template engines'
+      end
 
-            begin
-              # Look for the user's preferred engine
-              if config[:markdown_engine] == :redcarpet
-                require 'middleman-core/renderers/redcarpet'
-                ::Tilt.prefer(::Middleman::Renderers::RedcarpetTemplate, *markdown_exts)
-                MiddlemanRedcarpetHTML.middleman_app = self
-              elsif config[:markdown_engine] == :kramdown
-                require 'middleman-core/renderers/kramdown'
-                ::Tilt.prefer(::Middleman::Renderers::KramdownTemplate, *markdown_exts)
-                MiddlemanKramdownHTML.middleman_app = self
-              elsif config[:markdown_engine]
-                # Map symbols to classes
-                markdown_engine_klass = if config[:markdown_engine].is_a? Symbol
-                  engine = config[:markdown_engine].to_s
-                  engine = engine == 'rdiscount' ? 'RDiscount' : engine.camelize
-                  config[:markdown_engine_prefix].const_get("#{engine}Template")
-                else
-                  config[:markdown_engine_prefix]
-                end
+      # Once configuration is parsed
+      def after_configuration
+        markdown_exts = %w(markdown mdown md mkd mkdn)
 
-                # Tell tilt to use that engine
-                ::Tilt.prefer(markdown_engine_klass, *markdown_exts)
-              end
-            rescue LoadError
-              # If they just left it at the default engine and don't happen to have it,
-              # then they're using middleman-core bare and we shouldn't bother them.
-              if config.setting(:markdown_engine).value_set?
-                logger.warn "Requested Markdown engine (#{config[:markdown_engine]}) not found. Maybe the gem needs to be installed and required?"
-              end
+        begin
+          # Look for the user's preferred engine
+          if app.config[:markdown_engine] == :redcarpet
+            require 'middleman-core/renderers/redcarpet'
+            ::Tilt.prefer(::Middleman::Renderers::RedcarpetTemplate, *markdown_exts)
+          elsif app.config[:markdown_engine] == :kramdown
+            require 'middleman-core/renderers/kramdown'
+            ::Tilt.prefer(::Middleman::Renderers::KramdownTemplate, *markdown_exts)
+          elsif app.config[:markdown_engine]
+            # Map symbols to classes
+            markdown_engine_klass = if app.config[:markdown_engine].is_a? Symbol
+              engine = app.config[:markdown_engine].to_s
+              engine = engine == 'rdiscount' ? 'RDiscount' : engine.camelize
+              app.config[:markdown_engine_prefix].const_get("#{engine}Template")
+            else
+              app.config[:markdown_engine_prefix]
             end
+
+            # Tell tilt to use that engine
+            ::Tilt.prefer(markdown_engine_klass, *markdown_exts)
+          end
+        rescue LoadError
+          # If they just left it at the default engine and don't happen to have it,
+          # then they're using middleman-core bare and we shouldn't bother them.
+          if app.config.setting(:markdown_engine).value_set?
+            logger.warn "Requested Markdown engine (#{app.config[:markdown_engine]}) not found. Maybe the gem needs to be installed and required?"
           end
         end
-
-        alias_method :included, :registered
       end
     end
   end