middleman-core 4.5.1 → 5.0.0.rc.1

data/lib/middleman-core/step_definitions/middleman_steps.rb

@@ -1,16 +1,23 @@
 require 'fileutils'
 
-Given /^app "([^\"]*)" is using config "([^\"]*)"$/ do |path, config_name|
-  target = File.join(PROJECT_ROOT_PATH, 'fixtures', path)
-  config_path = File.join(expand_path("."), "config-#{config_name}.rb")
-  config_dest = File.join(expand_path("."), 'config.rb')
+Given /^app "([^\"]*)" is using config "([^\"]*)"$/ do |_path, config_name|
+  config_path = File.join(expand_path('.'), "config-#{config_name}.rb")
+  config_dest = File.join(expand_path('.'), 'config.rb')
   FileUtils.cp(config_path, config_dest)
 end
 
 Given /^an empty app$/ do
-  step %Q{a directory named "empty_app"}
-  step %Q{I cd to "empty_app"}
   ENV['MM_ROOT'] = nil
+
+  # This step can be reentered from several places but we don't want
+  # to keep re-copying and re-cd-ing into ever-deeper directories
+  next if File.basename(expand_path('.')) == 'empty_app'
+
+  step %(a directory named "empty_app")
+  step %(I cd to "empty_app")
+
+  cwd = File.expand_path(aruba.current_directory)
+  step %(I set the environment variable "MM_ROOT" to "#{cwd}")
 end
 
 Given /^a fixture app "([^\"]*)"$/ do |path|
@@ -18,14 +25,17 @@ Given /^a fixture app "([^\"]*)"$/ do |path|
 
   # This step can be reentered from several places but we don't want
   # to keep re-copying and re-cd-ing into ever-deeper directories
-  next if File.basename(expand_path(".")) == path
+  next if File.basename(expand_path('.')) == path
 
-  step %Q{a directory named "#{path}"}
+  step %(a directory named "#{path}")
 
   target_path = File.join(PROJECT_ROOT_PATH, 'fixtures', path)
-  FileUtils.cp_r(target_path, expand_path("."))
+  FileUtils.cp_r(target_path, expand_path('.'))
+
+  step %(I cd to "#{path}")
 
-  step %Q{I cd to "#{path}"}
+  cwd = File.expand_path(aruba.current_directory)
+  step %(I set the environment variable "MM_ROOT" to "#{cwd}")
 end
 
 Then /^the file "([^\"]*)" has the contents$/ do |path, contents|
@@ -35,18 +45,18 @@ Then /^the file "([^\"]*)" has the contents$/ do |path, contents|
 end
 
 Then /^the file "([^\"]*)" is removed$/ do |path|
-  FileUtils.rm(expand_path(path))
+  step %(I remove the file "#{path}")
 
   @server_inst.files.poll_once!
 end
 
 Given /^a modification time for a file named "([^\"]*)"$/ do |file|
-  target = File.join(expand_path("."), file)
+  target = File.join(expand_path('.'), file)
   @modification_times[target] = File.mtime(target)
 end
 
 Then /^the file "([^\"]*)" should not have been updated$/ do |file|
-  target = File.join(expand_path("."), file)
+  target = File.join(expand_path('.'), file)
   expect(File.mtime(target)).to eq(@modification_times[target])
 end
 
@@ -56,5 +66,5 @@ Then /^the file "([^"]*)" should contain '([^']*)'$/ do |file, partial_content|
 end
 
 And /the file "(.*)" should be gzipped/ do |file|
-  expect(File.binread(File.join(expand_path("."), file), 2)).to eq(['1F8B'].pack('H*'))
+  expect(File.binread(File.join(expand_path('.'), file), 2)).to eq(['1F8B'].pack('H*'))
 end

data/lib/middleman-core/step_definitions/server_steps.rb

@@ -1,7 +1,6 @@
 require 'middleman-core/rack'
 require 'rspec/expectations'
 require 'capybara/cucumber'
-require 'addressable/uri'
 
 Given /^a clean server$/ do
   @initialize_commands = []
@@ -11,9 +10,7 @@ end
 Given /^"([^\"]*)" feature is "([^\"]*)"$/ do |feature, state|
   @activation_commands ||= []
 
-  if state == 'enabled'
-    @activation_commands << lambda { activate(feature.to_sym) }
-  end
+  @activation_commands << -> { activate(feature.to_sym) } if state == 'enabled'
 end
 
 Given /^"([^\"]*)" feature is "enabled" with "([^\"]*)"$/ do |feature, options_str|
@@ -21,7 +18,7 @@ Given /^"([^\"]*)" feature is "enabled" with "([^\"]*)"$/ do |feature, options_s
 
   options = eval("{#{options_str}}")
 
-  @activation_commands << lambda { activate(feature.to_sym, options) }
+  @activation_commands << -> { activate(feature.to_sym, options) }
 end
 
 Given /^"([^\"]*)" is set to "([^\"]*)"$/ do |variable, value|
@@ -32,13 +29,13 @@ Given /^"([^\"]*)" is set to "([^\"]*)"$/ do |variable, value|
 end
 
 Given /^the Server is running$/ do
-  root_dir = File.expand_path(expand_path("."))
+  root_dir = File.expand_path(expand_path('.'))
 
-  if File.exist?(File.join(root_dir, 'source'))
-    ENV['MM_SOURCE'] = 'source'
-  else
-    ENV['MM_SOURCE'] = ''
-  end
+  ENV['MM_SOURCE'] = if File.exist?(File.join(root_dir, 'source'))
+                       'source'
+                     else
+                       ''
+                     end
 
   ENV['MM_ROOT'] = root_dir
 
@@ -55,7 +52,7 @@ Given /^the Server is running$/ do
 
     app.after_configuration_eval do
       activation_commands.each do |p|
-        config_context.instance_exec(&p)
+        instance_exec(&p)
       end
     end
   end
@@ -64,20 +61,24 @@ Given /^the Server is running$/ do
 end
 
 Given /^the Server is running at "([^\"]*)"$/ do |app_path|
-  step %Q{a fixture app "#{app_path}"}
-  step %Q{the Server is running}
+  step %(a fixture app "#{app_path}")
+  step %(the Server is running)
+end
+
+When /^the Server is reloaded$/ do
+  step %(the Server is running)
 end
 
 Given /^a template named "([^\"]*)" with:$/ do |name, string|
-  step %Q{a file named "source/#{name}" with:}, string
+  step %(a file named "source/#{name}" with:), string
 end
 
 When /^I go to "([^\"]*)"$/ do |url|
-  visit(Addressable::URI.encode(url))
+  visit(URI.encode(url).to_s)
 end
 
 Then /^going to "([^\"]*)" should not raise an exception$/ do |url|
-  expect { visit(Addressable::URI.encode(url)) }.to_not raise_exception
+  expect { visit(URI.encode(url).to_s) }.to_not raise_exception
 end
 
 Then /^the content type should be "([^\"]*)"$/ do |expected|
@@ -121,5 +122,5 @@ Then /^the status code should be "([^\"]*)"$/ do |expected|
 end
 
 Then /^I should see "([^\"]*)" lines$/ do |lines|
-  expect(page.body.chomp.split($/).length).to eq lines.to_i
+  expect(page.body.chomp.split($INPUT_RECORD_SEPARATOR).length).to eq lines.to_i
 end

data/lib/middleman-core/template_context.rb

@@ -1,7 +1,11 @@
 require 'pathname'
+require 'hamster'
 require 'middleman-core/file_renderer'
 require 'middleman-core/template_renderer'
+require 'middleman-core/data_proxy'
 require 'middleman-core/contracts'
+require 'middleman-core/dependencies/vertices/vertex'
+require 'middleman-core/dependencies/vertices/file_vertex'
 
 module Middleman
   # The TemplateContext Class
@@ -22,18 +26,32 @@ module Middleman
     # Required for Padrino's rendering
     attr_accessor :current_engine
 
+    # Points to the data proxy, which records data accesses
+    attr_reader :data
+
+    Contract ImmutableSetOf[::Middleman::Dependencies::Vertex]
+    attr_accessor :vertices
+
     # Shorthand references to global values on the app instance.
-    def_delegators :@app, :config, :logger, :sitemap, :server?, :build?, :environment?, :environment, :data, :extensions, :root, :development?, :production?
+    def_delegators :@app, :config, :logger, :sitemap, :server?, :build?, :environment?, :environment, :extensions, :root, :development?, :production?
 
     # Initialize a context with the current app and predefined locals and options hashes.
     #
     # @param [Middleman::Application] app
     # @param [Hash] locs
     # @param [Hash] opts
-    def initialize(app, locs={}, opts={})
+    def initialize(app, locs = {}, options_hash = ::Middleman::EMPTY_HASH)
       @app = app
-      @locs = locs
-      @opts = opts
+      @opts = options_hash
+
+      @vertices = ::Hamster::Set.empty
+      @data = DataProxy.new(self)
+
+      @locs = if @app.config[:track_data_access]
+                @data.take_ownership_of_proxies(locs)
+              else
+                locs
+              end
     end
 
     # Return the current buffer to the caller and clear the value internally.
@@ -42,7 +60,8 @@ module Middleman
     # @api private
     # @return [String] The old buffer.
     def save_buffer
-      @_out_buf, buf_was = '', @_out_buf
+      buf_was = @_out_buf
+      @_out_buf = ''
       buf_was
     end
 
@@ -85,6 +104,8 @@ module Middleman
         restore_buffer(buf_was)
       end
 
+      @vertices <<= ::Middleman::Dependencies::FileVertex.from_source_file(@app, layout_file)
+
       # Render the layout, with the contents of the block inside.
       concat_safe_content render_file(layout_file, @locs, @opts) { content }
     ensure
@@ -100,7 +121,7 @@ module Middleman
     # @param [Proc] block A block will be evaluated to return internal contents.
     # @return [String]
     Contract Any, Or[Symbol, String], Hash, Hash, Maybe[Proc] => String
-    def render(_, name, options={}, locals={}, &block)
+    def render(_, name, options_hash, locals, &block)
       name = name.to_s
 
       partial_file = locate_partial(name, false) || locate_partial(name, true)
@@ -108,16 +129,20 @@ module Middleman
       raise ::Middleman::TemplateRenderer::TemplateNotFound, "Could not locate partial: #{name}" unless partial_file
 
       source_path = sitemap.file_to_path(partial_file)
-      r = sitemap.find_resource_by_path(source_path)
+      r = sitemap.by_path(source_path)
 
-      if (r && !r.template?) || (Tilt[partial_file[:full_path]].nil? && partial_file[:full_path].exist?)
-        partial_file.read
-      else
-        opts = options.dup
-        locs = locals.dup
+      @vertices <<= ::Middleman::Dependencies::FileVertex.from_source_file(@app, partial_file)
 
-        render_file(partial_file, locs, opts, &block)
-      end
+      result = if (r && !r.template?) || (Tilt[partial_file[:full_path]].nil? && partial_file[:full_path].exist?)
+                 partial_file.read
+               else
+                 opts = options_hash.dup
+                 locs = locals
+
+                 render_file(partial_file, locs, opts, &block)
+               end
+
+      result
     end
 
     # Locate a partial relative to the current path or the source dir, given a partial's path.
@@ -126,30 +151,35 @@ module Middleman
     # @param [String] partial_path
     # @return [String]
     Contract String, Maybe[Bool] => Maybe[IsA['Middleman::SourceFile']]
-    def locate_partial(partial_path, try_static=true)
+    def locate_partial(partial_path, try_static = true)
       partial_file = nil
       lookup_stack = []
       non_root     = partial_path.to_s.sub(/^\//, '')
       non_root_no_underscore = non_root.sub(/^_/, '').sub(/\/_/, '/')
 
-      if resource = current_resource
+      if current_resource
+        resource = current_resource
         current_dir  = resource.file_descriptor[:relative_path].dirname
         relative_dir = current_dir + Pathname(non_root)
         relative_dir_no_underscore = current_dir + Pathname(non_root_no_underscore)
-      end
 
-      if relative_dir
-        lookup_stack.push [relative_dir.to_s,
-                           { preferred_engine: resource.file_descriptor[:relative_path]
-                             .extname[1..-1].to_sym }]
+        if relative_dir
+          lookup_stack.push [relative_dir.to_s,
+                             { preferred_engine: resource.file_descriptor[:relative_path]
+                                                         .extname[1..-1].to_sym }]
+        end
       end
+
       lookup_stack.push [non_root]
+
       lookup_stack.push [non_root,
                          { try_static: try_static }]
+
       if relative_dir_no_underscore
         lookup_stack.push [relative_dir_no_underscore.to_s,
                            { try_static: try_static }]
       end
+
       lookup_stack.push [non_root_no_underscore,
                          { try_static: try_static }]
 
@@ -169,7 +199,8 @@ module Middleman
     # @return [Middleman::Sitemap::Resource]
     def current_resource
       return nil unless current_path
-      sitemap.find_resource_by_destination_path(current_path)
+
+      sitemap.by_destination_path(current_path)
     end
     alias current_page current_resource
 
@@ -183,7 +214,7 @@ module Middleman
     # @param [Hash] opts Template options.
     # @param [Proc] block A block will be evaluated to return internal contents.
     # @return [String] The resulting content string.
-    Contract IsA['Middleman::SourceFile'], Hash, Hash, Maybe[Proc] => String
+    # Contract IsA['Middleman::SourceFile'], Hash, Hash, Maybe[Proc] => String
     def render_file(file, locs, opts, &block)
       _render_with_all_renderers(file[:relative_path].to_s, locs, self, opts, &block)
     end
@@ -200,6 +231,7 @@ module Middleman
 
           content_renderer = ::Middleman::FileRenderer.new(@app, path)
           content = content_renderer.render(locs, opts, context, &block)
+          @vertices |= content_renderer.vertices
 
           path = File.basename(path, File.extname(path))
         rescue LocalJumpError

data/lib/middleman-core/template_renderer.rb

@@ -1,8 +1,10 @@
 require 'tilt'
-require 'active_support/core_ext/string/output_safety'
+require 'hamster'
+require 'middleman-core/contracts'
 require 'middleman-core/template_context'
 require 'middleman-core/file_renderer'
-require 'middleman-core/contracts'
+require 'middleman-core/dependencies/vertices/vertex'
+require 'middleman-core/dependencies/vertices/file_vertex'
 
 module Middleman
   class TemplateRenderer
@@ -33,7 +35,7 @@ module Middleman
     # @param [Symbol] preferred_engine
     # @return [String]
     Contract IsA['Middleman::Application'], Or[String, Symbol], Symbol => Maybe[IsA['Middleman::SourceFile']]
-    def self.locate_layout(app, name, preferred_engine=nil)
+    def self.locate_layout(app, name, preferred_engine = nil)
       resolve_opts = {}
       resolve_opts[:preferred_engine] = preferred_engine unless preferred_engine.nil?
 
@@ -41,7 +43,7 @@ module Middleman
       layout_file = resolve_template(app, File.join(app.config[:layouts_dir], name.to_s), resolve_opts)
 
       # If we didn't find it, check root
-      layout_file = resolve_template(app, name, resolve_opts) unless layout_file
+      layout_file ||= resolve_template(app, name, resolve_opts)
 
       # Return the path
       layout_file
@@ -52,7 +54,7 @@ module Middleman
     # @option options [Boolean] :preferred_engine If set, try this engine first, then fall back to any engine.
     # @return [String, Boolean] Either the path to the template, or false
     Contract IsA['Middleman::Application'], Or[Symbol, String], Maybe[Hash] => Maybe[IsA['Middleman::SourceFile']]
-    def self.resolve_template(app, request_path, options={})
+    def self.resolve_template(app, request_path, options_hash = ::Middleman::EMPTY_HASH)
       # Find the path by searching
       relative_path = Util.strip_leading_slash(request_path.to_s)
 
@@ -60,15 +62,15 @@ module Middleman
       preferred_engines = []
 
       # If we're specifically looking for a preferred engine
-      if options.key?(:preferred_engine)
-        extension_class = ::Middleman::Util.tilt_class(options[:preferred_engine])
+      if options_hash.key?(:preferred_engine)
+        extension_class = ::Middleman::Util.tilt_class(options_hash[:preferred_engine])
 
         # Get a list of extensions for a preferred engine
         preferred_engines += ::Tilt.default_mapping.extensions_for(extension_class)
       end
 
       preferred_engines << '*'
-      preferred_engines << nil if options[:try_static]
+      preferred_engines << nil if options_hash[:try_static]
 
       found_template = nil
 
@@ -80,12 +82,12 @@ module Middleman
 
         # Cache lookups in build mode only
         file = if app.build?
-          cache.fetch(path_with_ext, preferred_engine) do
-            app.files.find(:source, path_with_ext, globbing)
-          end
-        else
-          app.files.find(:source, path_with_ext, globbing)
-        end
+                 cache.fetch(path_with_ext, preferred_engine) do
+                   app.files.find(:source, path_with_ext, globbing)
+                 end
+               else
+                 app.files.find(:source, path_with_ext, globbing)
+               end
 
         found_template = file if file && (preferred_engine.nil? || ::Middleman::Util.tilt_class(file[:full_path].to_s))
         break if found_template
@@ -98,9 +100,13 @@ module Middleman
     # Custom error class for handling
     class TemplateNotFound < RuntimeError; end
 
+    Contract ImmutableSetOf[::Middleman::Dependencies::Vertex]
+    attr_reader :vertices
+
     def initialize(app, path)
       @app = app
       @path = path
+      @vertices = ::Hamster::Set.empty
     end
 
     # Render a template, with layout, given a path
@@ -109,10 +115,20 @@ module Middleman
     # @param [Hash] opts
     # @return [String]
     Contract Hash, Hash => String
-    def render(locs={}, opts={}, &block)
+    def render(locals_hash = ::Middleman::EMPTY_HASH, options_hash = ::Middleman::EMPTY_HASH, &block)
       path = @path.dup
-      locals = locs.dup.freeze
-      options = opts.dup
+
+      locals = if locals_hash == ::Middleman::EMPTY_HASH
+                 locals_hash
+               else
+                 locals_hash.dup.freeze
+               end
+
+      options = if options_hash == ::Middleman::EMPTY_HASH
+                  options_hash
+                else
+                  options_hash.dup
+                end
 
       extension = File.extname(path)
       engine = extension[1..-1].to_sym
@@ -132,7 +148,7 @@ module Middleman
       @app.extensions.add_exposed_to_context(context)
 
       locals.each do |k, _|
-        next unless context.respond_to?(k) && ![:current_path, :paginate, :page_articles, :blog_controller, :lang, :locale, :data].include?(k.to_sym)
+        next unless context.respond_to?(k) && !%i[current_path paginate page_articles blog_controller lang locale data].include?(k.to_sym)
 
         msg = "Template local `#{k}` tried to overwrite an existing context value. Please rename the key when passing to `locals`"
 
@@ -143,24 +159,34 @@ module Middleman
         end
       end
 
+      @vertices = ::Hamster::Set.empty
+
       content = ::Middleman::Util.instrument 'builder.output.resource.render-template', path: File.basename(path) do
         _render_with_all_renderers(path, locals, context, options, &block)
       end
 
       # If we need a layout and have a layout, use it
       layout_file = fetch_layout(engine, options)
-      if layout_file
-        content = if layout_file = fetch_layout(engine, options)
-          layout_renderer = ::Middleman::FileRenderer.new(@app, layout_file[:relative_path].to_s)
 
-          ::Middleman::Util.instrument 'builder.output.resource.render-layout', path: File.basename(layout_file[:relative_path].to_s) do
-            layout_renderer.render(locals, options, context) { content }
-          end
-        else
-          content
-        end
+      if layout_file
+        layout_file = fetch_layout(engine, options)
+
+        content = if layout_file
+                    layout_renderer = ::Middleman::FileRenderer.new(@app, layout_file[:relative_path].to_s)
+
+                    ::Middleman::Util.instrument 'builder.output.resource.render-layout', path: File.basename(layout_file[:relative_path].to_s) do
+                      layout_renderer.render(locals, options, context) { content }.tap do
+                        @vertices <<= ::Middleman::Dependencies::FileVertex.from_source_file(@app, layout_file)
+                        @vertices |= layout_renderer.vertices
+                      end
+                    end
+                  else
+                    content
+                  end
       end
 
+      @vertices |= context.vertices
+
       # Return result
       content
     ensure
@@ -182,8 +208,9 @@ module Middleman
 
           content_renderer = ::Middleman::FileRenderer.new(@app, path)
           content = content_renderer.render(locs, opts, context, &block)
+          @vertices |= content_renderer.vertices
 
-          path = File.basename(path, File.extname(path))
+          path = path.sub(/\.[^.]*\z/, '')
         rescue LocalJumpError
           raise "Tried to render a layout (calls yield) at #{path} like it was a template. Non-default layouts need to be in #{@app.config[:source]}/#{@app.config[:layouts_dir]}."
         end
@@ -209,25 +236,24 @@ module Middleman
       # The engine for the layout can be set in options, engine_options or passed
       # into this method
       layout_engine = if opts.key?(:layout_engine)
-        opts[:layout_engine]
-      elsif engine_options.key?(:layout_engine)
-        engine_options[:layout_engine]
-      else
-        engine
-      end
+                        opts[:layout_engine]
+                      elsif engine_options.key?(:layout_engine)
+                        engine_options[:layout_engine]
+                      else
+                        engine
+                      end
 
       # Automatic mode
       if local_layout == :_auto_layout
         # Look for :layout of any extension
         # If found, use it. If not, continue
         locate_layout(:layout, layout_engine)
-      elsif layout_file = locate_layout(local_layout, layout_engine)
-        # Look for specific layout
-        # If found, use it. If not, error.
+      else
+        layout_file = locate_layout(local_layout, layout_engine)
+
+        raise ::Middleman::TemplateRenderer::TemplateNotFound, "Could not locate layout: #{local_layout}" unless layout_file
 
         layout_file
-      else
-        raise ::Middleman::TemplateRenderer::TemplateNotFound, "Could not locate layout: #{local_layout}"
       end
     end
 
@@ -236,7 +262,7 @@ module Middleman
     # @param [Symbol] preferred_engine
     # @return [String]
     Contract Or[String, Symbol], Symbol => Maybe[IsA['Middleman::SourceFile']]
-    def locate_layout(name, preferred_engine=nil)
+    def locate_layout(name, preferred_engine = nil)
       self.class.locate_layout(@app, name, preferred_engine)
     end
 
@@ -245,8 +271,8 @@ module Middleman
     # @param [Hash] options
     # @return [Array<String, Symbol>, Boolean]
     Contract String, Hash => ArrayOf[Or[String, Symbol]]
-    def resolve_template(request_path, options={})
-      self.class.resolve_template(@app, request_path, options)
+    def resolve_template(request_path, options_hash = ::Middleman::EMPTY_HASH)
+      self.class.resolve_template(@app, request_path, options_hash)
     end
   end
 end