middleman-core 4.3.11 → 5.0.0.rc.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a6c24e6aadd1825d0b97243b66abcfc1e1e55bd2614d2bb38d16e090eacf93d
-  data.tar.gz: 508ed84f8d68b46a4a8216d5faec3ca534e9c2e26afb8ce5bc0e7caa99bb21d1
+  metadata.gz: c9ae20287ab41e7c5d51cb9ca085342e32dea997a16ac5d7c85141b431078fa3
+  data.tar.gz: aee121169d1292d1874b8f44c4ef319ffd3d73a1f4c6bdb3cb15a1a7665d5834
 SHA512:
-  metadata.gz: 5ee86cb278396a0db2d9d7355cfcc4b48407499f3f24a41c0ab71d8776a89118311a5014ca194ea45dd4bdc0374e67341ac1e25aa8075758fc13d4776a56027f
-  data.tar.gz: 7cc9c4fbc9e0489aab97a206d9687bd5edca75f3e199b9e1d08e547d532e0d8c3abf1983b6abeaa52bb82826a28d632ebfe318571c73c6a52db602c1d0704f93
+  metadata.gz: 6996a9ebea798b8a75a9291c755f27f5fe78d4764b10620156b7a200f37c41514cac90ecf86bc6469d26f2290145c164f76957c59060f192fccb6f09b01fce77
+  data.tar.gz: 72f597c3499adb207ada5598e12c7e5368502b85859fd59a781660af4046bf8b6fc49a570a8cead124b38db0d8281643361449d21990c9a4fae5fe95d1f153c2

data/cucumber.yml

@@ -1,2 +1,2 @@
-default: --require features --tags ~@wip
-wip: --require features --tags @wip
+default: --fail-fast --require features --tags 'not @wip'
+wip: --fail-fast --require features --tags @wip

data/lib/middleman-core.rb

@@ -1,14 +1,16 @@
-# rubocop:disable FileName
-
 # Setup our load paths
-libdir = File.expand_path(File.dirname(__FILE__))
+libdir = __dir__
 $LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
 
+require 'backports/latest'
+require 'active_support/all'
+
 # Top-level Middleman namespace
 module Middleman
   autoload :Application, 'middleman-core/application'
 end
 
+require 'middleman-core/util/empty_hash'
 require 'middleman-core/version'
 require 'middleman-core/util'
 require 'middleman-core/extensions'

data/lib/middleman-core/application.rb

@@ -1,5 +1,4 @@
-require 'active_support/core_ext/integer/inflections'
-
+require 'hamster'
 require 'middleman-core/contracts'
 require 'middleman-core/callback_manager'
 require 'middleman-core/logger'
@@ -53,9 +52,6 @@ module Middleman
     # An anonymous subclass of ::Middleman::TemplateContext
     attr_reader :template_context_class
 
-    # An instance of the above anonymouse class.
-    attr_reader :generic_template_context
-
     Contract ::Middleman::Configuration::ConfigurationManager
     attr_reader :config
 
@@ -68,6 +64,9 @@ module Middleman
     Contract SetOf[MapDescriptor]
     attr_reader :mappings
 
+    Contract ImmutableSetOf[String]
+    attr_reader :set_of_extensions_with_layout
+
     # Which port preview should start on.
     # @return [Fixnum]
     define_setting :port, 4567, 'The preview server port'
@@ -158,11 +157,11 @@ module Middleman
 
     # Which file extensions have a layout by default.
     # @return [Array.<String>]
-    define_setting :extensions_with_layout, %w(.htm .html .xhtml .php), 'Which file extensions have a layout by default.'
+    define_setting :extensions_with_layout, %w[.htm .html .xhtml .php], 'Which file extensions have a layout by default.'
 
     # Which file extensions are "assets."
     # @return [Array.<String>]
-    define_setting :asset_extensions, %w(.css .png .jpg .jpeg .webp .svg .svgz .js .gif .ttf .otf .woff .woff2 .eot .ico .map), 'Which file extensions are treated as assets.'
+    define_setting :asset_extensions, %w[.css .png .jpg .jpeg .webp .svg .svgz .js .gif .ttf .otf .woff .woff2 .eot .ico .map], 'Which file extensions are treated as assets.'
 
     # Default string encoding for templates and output.
     # @return [String]
@@ -182,7 +181,7 @@ module Middleman
         ignored = false
 
         file[:relative_path].ascend do |f|
-          if f.basename.to_s =~ %r{^_[^_]}
+          if /^_[^_]/.match?(f.basename.to_s)
             ignored = true
             break
           end
@@ -191,13 +190,15 @@ module Middleman
         ignored
       end,
 
-      layout: ->(file, app) {
+      layout: lambda { |file, app|
         file[:relative_path].to_s.start_with?('layout.', app.config[:layouts_dir] + '/')
       }
     }, 'Callbacks that can exclude paths from the sitemap'
 
     define_setting :skip_build_clean, proc { |p| [/\.git/].any? { |r| p =~ r } }, 'Whether some paths should not be removed during a clean build.'
 
+    define_setting :data_collection_depth, ::Float::INFINITY, 'How deep to recurse into data structures when tracking changes.'
+
     define_setting :cli_options, {}, 'Options from the Command Line.'
 
     define_setting :watcher_disable, false, 'If the Listen watcher should not run'
@@ -209,7 +210,6 @@ module Middleman
     def_delegator :"::Middleman::Logger", :singleton, :logger
     def_delegator :"::Middleman::Util", :instrument
     def_delegators :"self.class", :root, :root_path
-    def_delegators :@generic_template_context, :link_to, :image_tag, :asset_path
     def_delegators :@extensions, :activate
     def_delegators :config, :define_setting
 
@@ -234,8 +234,6 @@ module Middleman
                                       :after_build,
                                       :before_shutdown,
                                       :before, # Before Rack requests
-                                      :before_render,
-                                      :after_render,
                                       :before_server,
                                       :reload
                                     ])
@@ -244,7 +242,6 @@ module Middleman
         @mappings = Set.new
 
         @template_context_class = Class.new(Middleman::TemplateContext)
-        @generic_template_context = @template_context_class.new(self)
         @config_context = ConfigContext.new(self, @template_context_class)
 
         # Setup the default values from calls to set before initialization
@@ -296,15 +293,15 @@ module Middleman
       # Post parsing, pre-extension callback
       execute_callbacks(:after_configuration_eval)
 
-      if Object.const_defined?(:Encoding)
-        Encoding.default_external = config[:encoding]
-      end
+      Encoding.default_external = config[:encoding] if Object.const_defined?(:Encoding)
 
       prune_tilt_templates!
 
       # After extensions have worked after_config
       execute_callbacks(:after_configuration)
 
+      @set_of_extensions_with_layout = ::Hamster::Set.new config.extensions_with_layout
+
       # Everything is stable
       execute_callbacks(:ready) unless config[:exit_before_ready]
     end
@@ -326,13 +323,13 @@ module Middleman
       config_rb = File.join(root, 'config.rb')
       if File.exist? config_rb
         logger.debug '== Reading: Local config: config.rb'
-        config_context.instance_eval File.read(config_rb), config_rb, 1
+        config_context.instance_eval ::Middleman::Util.read_file(config_rb), config_rb, 1
       else
         # Check for and evaluate local configuration in `middleman.rb`
         middleman_rb = File.join(root, 'middleman.rb')
         if File.exist? middleman_rb
           logger.debug '== Reading: Local middleman: middleman.rb'
-          config_context.instance_eval File.read(middleman_rb), middleman_rb, 1
+          config_context.instance_eval ::Middleman::Util.read_file(middleman_rb), middleman_rb, 1
         end
       end
 
@@ -340,18 +337,19 @@ module Middleman
       return unless File.exist? env_config
 
       logger.debug "== Reading: #{config[:environment]} config"
-      config_context.instance_eval File.read(env_config), env_config, 1
+      config_context.instance_eval ::Middleman::Util.read_file(env_config), env_config, 1
     end
 
     # Clean up missing Tilt exts
     def prune_tilt_templates!
-      ::Tilt.default_mapping.lazy_map.each_key do |key|
+      mapping = ::Tilt.default_mapping
+      mapping.lazy_map.each_key do |key|
         begin
-          ::Tilt[".#{key}"]
+          mapping[key]
         rescue LoadError, NameError
-          ::Tilt.default_mapping.lazy_map.delete(key)
         end
       end
+      mapping.lazy_map.clear
     end
 
     # Whether we're in a specific mode
@@ -438,10 +436,10 @@ module Middleman
     #
     # @deprecated Prefer accessing settings through "config".
     #
-    # @param [Symbol] key Name of the attribue
+    # @param [Symbol] key Name of the attribute
     # @param value Attribute value
     # @return [void]
-    def set(key, value=nil, &block)
+    def set(key, value = nil, &block)
       logger.warn "Warning: `set :#{key}` is deprecated. Use `config[:#{key}] =` instead."
 
       value = block if block_given?

data/lib/middleman-core/builder.rb

@@ -2,7 +2,9 @@ require 'pathname'
 require 'fileutils'
 require 'tempfile'
 require 'parallel'
-require 'middleman-core/rack'
+require 'middleman-core/dependencies/graph'
+require 'middleman-core/dependencies/edge'
+require 'middleman-core/dependencies/vertices/file_vertex'
 require 'middleman-core/callback_manager'
 require 'middleman-core/contracts'
 
@@ -21,26 +23,26 @@ module Middleman
     def_delegator :@app, :logger
 
     # Sort order, images, fonts, js/css and finally everything else.
-    SORT_ORDER = %w(.png .jpeg .jpg .gif .bmp .svg .svgz .webp .ico .woff .woff2 .otf .ttf .eot .js .css).freeze
+    SORT_ORDER = %w[.png .jpeg .jpg .gif .bmp .svg .svgz .webp .ico .woff .woff2 .otf .ttf .eot .js .mjs .css].freeze
 
     # Create a new Builder instance.
     # @param [Middleman::Application] app The app to build.
     # @param [Hash] opts The builder options
-    def initialize(app, opts={})
+    def initialize(app, options_hash = ::Middleman::EMPTY_HASH)
       @app = app
       @source_dir = Pathname(File.join(@app.root, @app.config[:source]))
       @build_dir = Pathname(@app.config[:build_dir])
 
-      if @build_dir.expand_path.relative_path_from(@source_dir).to_s =~ /\A[.\/]+\Z/
-        raise ":build_dir (#{@build_dir}) cannot be a parent of :source_dir (#{@source_dir})"
-      end
-
-      @glob = opts.fetch(:glob)
-      @cleaning = opts.fetch(:clean)
-      @parallel = opts.fetch(:parallel, true)
+      raise ":build_dir (#{@build_dir}) cannot be a parent of :source_dir (#{@source_dir})" if /\A[.\/]+\Z/.match?(@build_dir.expand_path.relative_path_from(@source_dir).to_s)
 
-      rack_app = ::Middleman::Rack.new(@app).to_app
-      @rack = ::Rack::MockRequest.new(rack_app)
+      @glob = options_hash.fetch(:glob)
+      @parallel = options_hash.fetch(:parallel, true)
+      @only_changed = options_hash.fetch(:only_changed, false)
+      @missing_and_changed = options_hash.fetch(:missing_and_changed, false)
+      @track_dependencies = options_hash.fetch(:track_dependencies, false)
+      @visualize_graph = @track_dependencies && options_hash.fetch(:visualize_graph, false)
+      @dry_run = options_hash.fetch(:dry_run)
+      @cleaning = !@dry_run && options_hash.fetch(:clean)
 
       @callbacks = ::Middleman::CallbackManager.new
       @callbacks.install_methods!(self, [:on_build_event])
@@ -53,6 +55,40 @@ module Middleman
       @has_error = false
       @events = {}
 
+      if @track_dependencies
+        begin
+          ::Middleman::Util.instrument 'dependencies.load_and_deserialize' do
+            @graph = ::Middleman::Dependencies.load_and_deserialize(@app)
+          end
+        rescue ::Middleman::Dependencies::InvalidDepsYAML
+          logger.error 'dep.yml was corrupt. Dependency graph must be rebuilt.'
+          @graph = ::Middleman::Dependencies::Graph.new
+          @only_changed = @missing_and_changed = false
+        rescue ::Middleman::Dependencies::ChangedDepth
+          logger.error ':data_collection_depth changed. Dependency graph must be rebuilt.'
+          @graph = ::Middleman::Dependencies::Graph.new
+          @only_changed = @missing_and_changed = false
+        rescue ::Middleman::Dependencies::InvalidatedGlobalFiles => e
+          changed = e.invalidated.join(', ')
+          logger.error "Some global files (#{changed}) have changed since last run. Dependency graph must be rebuilt."
+
+          @graph = ::Middleman::Dependencies::Graph.new
+          @only_changed = @missing_and_changed = false
+        end
+      end
+
+      if @only_changed || @missing_and_changed
+        @invalidated_files = @graph.invalidated
+
+        if @invalidated_files.empty?
+          logger.debug '== No invalidated files'
+        else
+          @invalidated_files.each do |v|
+            logger.debug "== Invalidated: #{v}"
+          end
+        end
+      end
+
       ::Middleman::Util.instrument 'builder.before' do
         @app.execute_callbacks(:before_build, [self])
       end
@@ -62,18 +98,36 @@ module Middleman
       end
 
       ::Middleman::Util.instrument 'builder.prerender' do
-        prerender_css
+        prerender_css.tap do |resources|
+          if @track_dependencies
+            resources.each do |r|
+              @graph.add_edge_set(r[1]) unless r[1].nil?
+            end
+          end
+        end
       end
 
       ::Middleman::Profiling.start
 
       ::Middleman::Util.instrument 'builder.output' do
-        output_files
+        output_files.tap do |resources|
+          if @track_dependencies
+            resources.each do |r|
+              @graph.add_edge_set(r[1]) unless r[1].nil?
+            end
+          end
+        end
       end
 
       ::Middleman::Profiling.report('build')
 
       unless @has_error
+        partial_update_with_no_changes = (@only_changed || @missing_and_changed) && @invalidated_files.empty?
+
+        ::Middleman::Dependencies.serialize_and_save(@app, @graph) if @track_dependencies && !partial_update_with_no_changes
+
+        ::Middleman::Dependencies.visualize_graph(@app, @graph) if @track_dependencies && @visualize_graph
+
         ::Middleman::Util.instrument 'builder.clean' do
           clean! if @cleaning
         end
@@ -88,12 +142,13 @@ module Middleman
 
     # Pre-request CSS to give Compass a chance to build sprites
     # @return [Array<Resource>] List of css resources that were output.
-    Contract ResourceList
+    Contract ArrayOf[[Pathname, Maybe[::Middleman::Dependencies::Edge]]]
     def prerender_css
       logger.debug '== Prerendering CSS'
 
+      resources = @app.sitemap.by_extension('.css').to_a
+
       css_files = ::Middleman::Util.instrument 'builder.prerender.output' do
-        resources = @app.sitemap.resources.select { |resource| resource.ext == '.css' }
         output_resources(resources)
       end
 
@@ -110,65 +165,112 @@ module Middleman
 
     # Find all the files we need to output and do so.
     # @return [Array<Resource>] List of resources that were output.
-    Contract ResourceList
+    Contract ArrayOf[[Pathname, Maybe[::Middleman::Dependencies::Edge]]]
     def output_files
       logger.debug '== Building files'
 
-      resources = @app.sitemap.resources
-                      .reject { |resource| resource.ext == '.css' }
-                      .sort_by { |resource| SORT_ORDER.index(resource.ext) || 100 }
+      non_css_resources = @app.sitemap.without_ignored - @app.sitemap.by_extension('.css')
 
-      if @glob
-        resources = resources.select do |resource|
-          if defined?(::File::FNM_EXTGLOB)
-            File.fnmatch(@glob, resource.destination_path, ::File::FNM_EXTGLOB)
-          else
-            File.fnmatch(@glob, resource.destination_path)
-          end
-        end
-      end
+      resources = non_css_resources
+                  .sort_by { |resource| SORT_ORDER.index(resource.ext) || 100 }
 
-      output_resources(resources)
+      output_resources(resources.to_a)
     end
 
-    Contract ResourceList => ResourceList
+    Contract OldResourceList => ArrayOf[Or[Bool, [Pathname, Maybe[::Middleman::Dependencies::Edge]]]]
     def output_resources(resources)
-      results = if @parallel
-        ::Parallel.map(resources, &method(:output_resource))
-      else
-        resources.map(&method(:output_resource))
-      end
+      res_count = resources.count
 
-      @has_error = true if results.any? { |r| r == false }
+      return resources if res_count.zero?
+
+      results = if @parallel
+                  processes = ::Parallel.processor_count
+                  processes = processes < res_count ? processes : res_count
+                  min_parts = res_count / processes
+                  remainder = res_count % processes
+                  offset = 0
+                  ranges = []
+
+                  while offset < res_count
+                    end_r = offset + min_parts
+
+                    if remainder.positive?
+                      end_r += 1
+                      remainder -= 1
+                    end
+
+                    range = offset...end_r
+                    offset = end_r
+                    ranges << range
+                  end
+
+                  outputs = Parallel.map(ranges, in_processes: processes) do |r|
+                    resources[r].map! { |res| output_resource(res, true) }
+                  end
+
+                  outputs.flatten!(1)
+                  outputs.map do |pair|
+                    if pair == false
+                      false
+                    else
+                      output_file = pair[0]
+
+                      serialized_dep = pair[1]
+
+                      edge = if serialized_dep.nil?
+                               nil
+                             else
+                               self_vertex = ::Middleman::Dependencies.deserialize_vertex(@app, serialized_dep[:self_vertex])
+                               depends_on = serialized_dep[:depends_on].map { |d| ::Middleman::Dependencies.deserialize_vertex(@app, d) }
+
+                               ::Middleman::Dependencies::Edge.new(
+                                 self_vertex,
+                                 depends_on << self_vertex
+                               )
+                             end
+
+                      [output_file, edge]
+                    end
+                  end
+                else
+                  resources.map(&method(:output_resource))
+                end
+
+      without_errors = results.reject { |r| r == false }
+
+      @has_error = results.size > without_errors.size
 
       if @cleaning && !@has_error
-        results.each do |p|
+        results.each do |r|
+          p = r[0]
           next unless p.exist?
 
           # handle UTF-8-MAC filename on MacOS
-          cleaned_name = if RUBY_PLATFORM =~ /darwin/
-            p.to_s.encode('UTF-8', 'UTF-8-MAC')
-          else
-            p
-          end
+          cleaned_name = if RUBY_PLATFORM.match?(/darwin/)
+                           p.to_s.encode('UTF-8', 'UTF-8-MAC')
+                         else
+                           p
+                         end
 
           @to_clean.delete(Pathname(cleaned_name))
         end
       end
 
-      resources
+      without_errors
     end
 
     # Figure out the correct event mode.
     # @param [Pathname] output_file The output file path.
     # @param [String] source The source file path.
     # @return [Symbol]
-    Contract Pathname, String => Symbol
-    def which_mode(output_file, source)
+    Contract Pathname, String, Bool => Symbol
+    def which_mode(output_file, source, binary)
       if !output_file.exist?
         :created
+      elsif FileUtils.compare_file(source.to_s, output_file.to_s)
+        binary ? :skipped : :identical
       else
-        FileUtils.compare_file(source.to_s, output_file.to_s) ? :identical : :updated
+        :updated
       end
     end
 
@@ -185,7 +287,6 @@ module Middleman
       file.binmode
       file.write(contents)
       file.close
-      File.chmod(0o644, file)
       file
     end
 
@@ -193,58 +294,94 @@ module Middleman
     # @param [Pathname] output_file The path to output to.
     # @param [String|Pathname] source The source path or contents.
     # @return [void]
-    Contract Pathname, Or[String, Pathname] => Any
-    def export_file!(output_file, source)
-      # ::Middleman::Util.instrument "write_file", output_file: output_file do
-      source = write_tempfile(output_file, source.to_s) if source.is_a? String
+    Contract Pathname, Or[String, Pathname], Maybe[Bool] => Any
+    def export_file!(output_file, source, binary = false)
+      return if @dry_run
 
-      method, source_path = if source.is_a? Tempfile
-        [::FileUtils.method(:mv), source.path]
-      else
-        [::FileUtils.method(:cp), source.to_s]
-      end
+      ::Middleman::Util.instrument 'write_file', output_file: output_file do
+        source = write_tempfile(output_file, source.to_s) if source.is_a? String
 
-      mode = which_mode(output_file, source_path)
+        method, source_path = if source.is_a? Tempfile
+                                [::FileUtils.method(:mv), source.path]
+                              else
+                                [::FileUtils.method(:cp), source.to_s]
+                              end
 
-      if mode == :created || mode == :updated
-        ::FileUtils.mkdir_p(output_file.dirname)
-        method.call(source_path, output_file.to_s)
-      end
+        mode = which_mode(output_file, source_path, binary)
+
+        if %i[created updated].include?(mode)
+          ::FileUtils.mkdir_p(output_file.dirname)
+          method.call(source_path, output_file.to_s)
+          ::File.chmod(0o644, output_file.to_s)
+        end
 
-      source.unlink if source.is_a? Tempfile
+        source.unlink if source.is_a? Tempfile
 
-      trigger(mode, output_file)
-      # end
+        trigger(mode, output_file)
+      end
     end
 
     # Try to output a resource and capture errors.
     # @param [Middleman::Sitemap::Resource] resource The resource.
     # @return [void]
-    Contract IsA['Middleman::Sitemap::Resource'] => Or[Pathname, Bool]
-    def output_resource(resource)
+    SERIALIZED_DEP = { self_vertex: ::Middleman::Dependencies::Vertex::SERIALIZED_VERTEX, depends_on: ImmutableSetOf[::Middleman::Dependencies::Vertex::SERIALIZED_VERTEX] }.freeze
+    Contract IsA['Middleman::Sitemap::Resource'], Maybe[Bool] => Or[Bool, [Pathname, Maybe[Or[SERIALIZED_DEP, ::Middleman::Dependencies::Edge]]]]
+    def output_resource(resource, serialize_deps = false)
       ::Middleman::Util.instrument 'builder.output.resource', path: File.basename(resource.destination_path) do
-        output_file = @build_dir + resource.destination_path.gsub('%20', ' ')
-
         begin
-          if resource.binary?
-            export_file!(output_file, resource.file_descriptor[:full_path])
-          else
-            response = @rack.get(::URI.escape(resource.request_path))
-
-            # If we get a response, save it to a tempfile.
-            if response.status == 200
-              export_file!(output_file, binary_encode(response.body))
-            else
-              trigger(:error, output_file, response.body)
-              return false
+          output_file = @build_dir + resource.destination_path.gsub('%20', ' ')
+
+          if @track_dependencies && (@only_changed || @missing_and_changed)
+            invalidated_resource = @graph.invalidates_resource?(resource)
+            if @only_changed && !invalidated_resource
+              trigger(:skipped, output_file)
+              return [output_file, nil]
+            elsif @missing_and_changed && File.exist?(output_file) && !invalidated_resource
+              trigger(:skipped, output_file)
+              return [output_file, nil]
             end
+          elsif @glob
+            did_match = if defined?(::File::FNM_EXTGLOB)
+                          File.fnmatch(@glob, resource.destination_path, ::File::FNM_EXTGLOB)
+                        else
+                          File.fnmatch(@glob, resource.destination_path)
+                        end
+
+            unless did_match
+              trigger(:skipped, output_file)
+              return [output_file, nil]
+            end
+          end
+
+          edge = nil
+
+          if resource.binary? || resource.static_file?
+            export_file!(output_file, resource.file_descriptor[:full_path], true)
+          else
+            content = resource.render({}, {})
+
+            self_vertex = ::Middleman::Dependencies::FileVertex.from_resource(resource)
+
+            edge = if serialize_deps
+                     {
+                       self_vertex: self_vertex.serialize,
+                       depends_on: resource.vertices.map(&:serialize)
+                     }
+                   else
+                     ::Middleman::Dependencies::Edge.new(
+                       self_vertex,
+                       resource.vertices << self_vertex
+                     )
+                   end
+
+            export_file!(output_file, binary_encode(content))
           end
-        rescue => e
+        rescue StandardError => e
           trigger(:error, output_file, "#{e}\n#{e.backtrace.join("\n")}")
           return false
         end
 
-        output_file
+        [output_file, edge]
       end
     end
 
@@ -267,7 +404,7 @@ module Middleman
 
       # handle UTF-8-MAC filename on MacOS
       @to_clean = @to_clean.map do |path|
-        if RUBY_PLATFORM =~ /darwin/
+        if RUBY_PLATFORM.match?(/darwin/)
           Pathname(path.to_s.encode('UTF-8', 'UTF-8-MAC'))
         else
           Pathname(path)
@@ -295,7 +432,7 @@ module Middleman
     end
 
     Contract Symbol, Or[String, Pathname], Maybe[String] => Any
-    def trigger(event_type, target, extra=nil)
+    def trigger(event_type, target, extra = nil)
       @events[event_type] ||= []
       @events[event_type] << target