Convert renderers into first-class extensions

middleman-core/lib/middleman-core/application.rb

@@ -53,6 +53,9 @@ module Middleman
     # Runs after the build is finished
     define_hook :after_build
 
+    define_hook :before_render
+    define_hook :after_render
+
     # Root project directory (overwritten in middleman build/server)
     # @return [String]
     def self.root
@@ -166,9 +169,6 @@ module Middleman
     # Basic Rack Request Handling
     include Middleman::CoreExtensions::Request
 
-    # Setup custom rendering
-    include Middleman::CoreExtensions::Rendering
-
     # Reference to Logger singleton
     def_delegator :"::Middleman::Logger", :singleton, :logger
 
@@ -226,7 +226,7 @@ module Middleman
       if config[:autoload_sprockets]
         begin
           require 'middleman-sprockets'
-          activate :sprockets
+          @extensions.activate :sprockets
         rescue LoadError
           # It's OK if somebody is using middleman-core without middleman-sprockets
         end
@@ -249,6 +249,15 @@ module Middleman
         ::I18n.reload!
       end
 
+      # Clean up missing Tilt exts
+      Tilt.mappings.each do |key, _|
+        begin
+          Tilt[".#{key}"]
+        rescue LoadError, NameError
+          Tilt.mappings.delete(key)
+        end
+      end
+
       run_hook :after_configuration
       config_context.execute_after_configuration_callbacks
 

middleman-core/lib/middleman-core/core_extensions/rendering.rb

@@ -1,90 +1,55 @@
 require 'middleman-core/template_context'
 
-# Rendering extension
+# ERb Support
-module Middleman
+Middleman::Extensions.register :erb_renderer, auto_activate: :before_configuration do
-  module CoreExtensions
+  require 'middleman-core/renderers/erb'
-    module Rendering
+  Middleman::Renderers::ERb
-      # Setup extension
+end
-      class << self
+
-        # Once registered
+# CoffeeScript Support
-        def included(app)
+Middleman::Extensions.register :coffee_renderer, auto_activate: :before_configuration do
-          app.define_hook :before_render
+  require 'middleman-core/renderers/coffee_script'
-          app.define_hook :after_render
+  Middleman::Renderers::CoffeeScript
-
+end
-          ::Tilt.mappings.delete('html') # WTF, Tilt?
+
-          ::Tilt.mappings.delete('csv')
+# Haml Support
-
+Middleman::Extensions.register :haml_renderer, auto_activate: :before_configuration do
-          require 'active_support/core_ext/string/output_safety'
+  require 'middleman-core/renderers/haml'
-
+  Middleman::Renderers::Haml
-          # Activate custom renderers
+end
-          require 'middleman-core/renderers/erb'
+
-          app.send :include, Middleman::Renderers::ERb
+# Sass Support
-
+Middleman::Extensions.register :sass_renderer, auto_activate: :before_configuration do
-          # CoffeeScript Support
+  require 'middleman-core/renderers/sass'
-          begin
+  Middleman::Renderers::Sass
-            require 'middleman-core/renderers/coffee_script'
+end
-            app.send :include, Middleman::Renderers::CoffeeScript
+
-          rescue LoadError
+# Markdown Support
-          end
+Middleman::Extensions.register :markdown_renderer, auto_activate: :before_configuration do
-
+  require 'middleman-core/renderers/markdown'
-          # Haml Support
+  Middleman::Renderers::Markdown
-          begin
+end
-            require 'middleman-core/renderers/haml'
+
-            app.send :include, Middleman::Renderers::Haml
+# Liquid Support
-          rescue LoadError
+Middleman::Extensions.register :liquid_renderer, auto_activate: :before_configuration do
-          end
+  require 'middleman-core/renderers/liquid'
-
+  Middleman::Renderers::Liquid
-          # Sass Support
+end
-          begin
+
-            require 'middleman-core/renderers/sass'
+# Slim Support
-            app.send :include, Middleman::Renderers::Sass
+Middleman::Extensions.register :slim_renderer, auto_activate: :before_configuration do
-          rescue LoadError
+  require 'middleman-core/renderers/slim'
-          end
+  Middleman::Renderers::Slim
-
+end
-          # Markdown Support
+
-          require 'middleman-core/renderers/markdown'
+# Less Support
-          app.send :include, Middleman::Renderers::Markdown
+Middleman::Extensions.register :less_renderer, auto_activate: :before_configuration do
-
+  require 'middleman-core/renderers/less'
-          # Liquid Support
+  Middleman::Renderers::Less
-          begin
+end
-            require 'middleman-core/renderers/liquid'
+
-            Middleman::Extensions.register :liquid, Middleman::Renderers::Liquid, auto_activate: :before_configuration
+# Stylus Support
-          rescue LoadError
+Middleman::Extensions.register :stylus_renderer, auto_activate: :before_configuration do
-          end
+  require 'middleman-core/renderers/stylus'
-
+  Middleman::Renderers::Stylus
-          # Slim Support
-          begin
-            require 'middleman-core/renderers/slim'
-            app.send :include, Middleman::Renderers::Slim
-          rescue LoadError
-          end
-
-          # Less Support
-          begin
-            require 'middleman-core/renderers/less'
-            app.send :include, Middleman::Renderers::Less
-          rescue LoadError
-          end
-
-          # Stylus Support
-          begin
-            require 'middleman-core/renderers/stylus'
-            app.send :include, Middleman::Renderers::Stylus
-          rescue LoadError
-          end
-
-          # Clean up missing Tilt exts
-          app.after_configuration do
-            Tilt.mappings.each do |key, _|
-              begin
-                Tilt[".#{key}"]
-              rescue LoadError, NameError
-                Tilt.mappings.delete(key)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
 end

middleman-core/lib/middleman-core/extension_manager.rb

@@ -1,7 +1,7 @@
 module Middleman
   class ExtensionManager
     extend Forwardable
-    def_delegator :"::Middleman::Logger", :singleton, :logger
+    def_delegator :@app, :logger
     def_delegators :@activated, :[]
 
     def initialize(app)
@@ -32,7 +32,13 @@ module Middleman
     # @yield [Middleman::Configuration::ConfigurationManager] Extension options that can be modified before the extension is initialized.
     # @return [void]
     def activate(ext_name, options={}, &block)
-      extension = ::Middleman::Extensions.load(ext_name)
+      begin
+        extension = ::Middleman::Extensions.load(ext_name)
+      rescue LoadError => e
+        logger.debug "== Failed Activation `#{ext_name}` : #{e.message}"
+        return
+      end
+
       logger.debug "== Activating: #{ext_name}"
 
       if extension.supports_multiple_instances?

middleman-core/lib/middleman-core/file_renderer.rb

@@ -1,6 +1,9 @@
 require 'tilt'
 require 'active_support/core_ext/string/output_safety'
 
+::Tilt.mappings.delete('html') # WTF, Tilt?
+::Tilt.mappings.delete('csv')
+
 module Middleman
   class FileRenderer
     extend Forwardable

middleman-core/lib/middleman-core/preview_server.rb

@@ -94,6 +94,12 @@ module Middleman
 
       def new_app
         opts = @options.dup
+
+        ::Middleman::Logger.singleton(
+          opts[:debug] ? 0 : 1,
+          opts[:instrumenting] || false
+        )
+
         server = ::Middleman::Application.server
 
         # Add in the meta pages application
@@ -103,11 +109,6 @@ module Middleman
         end
 
         @app = server.inst do
-          ::Middleman::Logger.singleton(
-            opts[:debug] ? 0 : 1,
-            opts[:instrumenting] || false
-          )
-
           config[:environment] = opts[:environment].to_sym if opts[:environment]
         end
       end

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

@@ -4,20 +4,18 @@ require 'coffee_script'
 module Middleman
   module Renderers
     # CoffeeScript Renderer
-    module CoffeeScript
+    class CoffeeScript < ::Middleman::Extension
       # Setup extension
-      class << self
+      def initialize(app, options={}, &block)
-        # Once registered
+        super
-        def registered(app)
-          # Tell Tilt to use it as well (for inline scss blocks)
-          ::Tilt.register 'coffee', DebuggingCoffeeScriptTemplate
-          ::Tilt.prefer(DebuggingCoffeeScriptTemplate)
 
-          app.before_configuration do
+        # Tell Tilt to use it as well (for inline scss blocks)
-            DebuggingCoffeeScriptTemplate.middleman_app = self
+        ::Tilt.register 'coffee', DebuggingCoffeeScriptTemplate
-          end
+        ::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

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

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

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

@@ -37,19 +37,16 @@ module Middleman
     end
 
     # Haml Renderer
-    module Haml
+    class Haml < ::Middleman::Extension
-      mattr_accessor :last_haml_scope
+      cattr_accessor :last_haml_scope
 
-      # Setup extension
+      def initialize(app, options={}, &block)
-      class << self
+        super
-        # Once registered
-        def registered(_)
-          ::Tilt.prefer(::Middleman::Renderers::HamlTemplate, :haml)
 
-          # Add haml helpers to context
+        ::Tilt.prefer(::Middleman::Renderers::HamlTemplate, :haml)
-          ::Middleman::TemplateContext.send :include, ::Haml::Helpers
+
-        end
+        # Add haml helpers to context
-        alias_method :included, :registered
+        ::Middleman::TemplateContext.send :include, ::Haml::Helpers
       end
     end
   end

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

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

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

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

middleman-core/lib/middleman-core/renderers/sass.rb

@@ -33,33 +33,30 @@ end
 module Middleman
   module Renderers
     # Sass renderer
-    module Sass
+    class Sass < ::Middleman::Extension
       # Setup extension
-      class << self
+      def initialize(app, options={}, &block)
-        # Once registered
+        super
-        def registered(app)
-          opts = { output_style: :nested }
-          opts[:line_comments] = false if ENV['TEST']
 
-          # Default sass options
+        opts = { output_style: :nested }
-          app.config.define_setting :sass, opts, 'Sass engine options'
+        opts[:line_comments] = false if ENV['TEST']
 
-          app.config.define_setting :sass_assets_paths, [], 'Paths to extra SASS/SCSS files'
+        # Default sass options
+        app.config.define_setting :sass, opts, 'Sass engine options'
 
-          # Tell Tilt to use it as well (for inline sass blocks)
+        app.config.define_setting :sass_assets_paths, [], 'Paths to extra SASS/SCSS files'
-          ::Tilt.register 'sass', SassPlusCSSFilenameTemplate
-          ::Tilt.prefer(SassPlusCSSFilenameTemplate)
 
-          # Tell Tilt to use it as well (for inline scss blocks)
+        # Tell Tilt to use it as well (for inline sass blocks)
-          ::Tilt.register 'scss', ScssPlusCSSFilenameTemplate
+        ::Tilt.register 'sass', SassPlusCSSFilenameTemplate
-          ::Tilt.prefer(ScssPlusCSSFilenameTemplate)
+        ::Tilt.prefer(SassPlusCSSFilenameTemplate)
 
-          ::Compass::ImportOnce.activate!
+        # Tell Tilt to use it as well (for inline scss blocks)
+        ::Tilt.register 'scss', ScssPlusCSSFilenameTemplate
+        ::Tilt.prefer(ScssPlusCSSFilenameTemplate)
 
-          require 'middleman-core/renderers/sass_functions'
+        ::Compass::ImportOnce.activate!
-        end
 
-        alias_method :included, :registered
+        require 'middleman-core/renderers/sass_functions'
       end
 
       # A SassTemplate for Tilt which outputs debug messages

middleman-core/lib/middleman-core/renderers/slim.rb

@@ -18,32 +18,27 @@ end
 module Middleman
   module Renderers
     # Slim renderer
-    module Slim
+    class Slim < ::Middleman::Extension
       # Setup extension
-      class << self
+      def initialize(_app, _options={}, &_block)
-        # Once registered
+        # Setup Slim options to work with partials
-        def registered(app)
+        ::Slim::Engine.set_default_options(
-          # Setup Slim options to work with partials
+          buffer: '@_out_buf',
-          ::Slim::Engine.set_default_options(
+          use_html_safe: true,
-            buffer: '@_out_buf',
+          generator: ::Temple::Generators::RailsOutputBuffer,
-            use_html_safe: true,
+          disable_escape: true
-            generator: ::Temple::Generators::RailsOutputBuffer,
+        )
-            disable_escape: true
+      end
-          )
 
-          app.after_configuration do
+      def after_configuration
-            context_hack = {
+        context_hack = {
-              context: template_context_class.new(self)
+          context: app.template_context_class.new(self)
-            }
+        }
 
-            ::Slim::Embedded::SassEngine.disable_option_validator!
+        ::Slim::Embedded::SassEngine.disable_option_validator!
-            %w(sass scss markdown).each do |engine|
+        %w(sass scss markdown).each do |engine|
-              ::Slim::Embedded.default_options[engine.to_sym] = context_hack
+          ::Slim::Embedded.default_options[engine.to_sym] = context_hack
-            end
-          end
         end
-
-        alias_method :included, :registered
       end
     end
   end

middleman-core/lib/middleman-core/renderers/stylus.rb

@@ -3,17 +3,11 @@ require 'stylus/tilt'
 
 module Middleman
   module Renderers
-    # Sass renderer
+    class Stylus < ::Middleman::Extension
-    module Stylus
+      def initialize(app, options={}, &block)
-      # Setup extension
+        super
-      class << self
-        # Once registered
-        def registered(app)
-          # Default stylus options
-          app.config.define_setting :styl, {}, 'Stylus config options'
-        end
 
-        alias_method :included, :registered
+        app.config.define_setting :styl, {}, 'Stylus config options'
       end
     end
   end