middleman-core-with-external-sources-watch-fix 4.1.0

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

@@ -0,0 +1,60 @@
+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')
+  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
+end
+
+Given /^a fixture app "([^\"]*)"$/ do |path|
+  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(".")) == path
+
+  step %Q{a directory named "#{path}"}
+
+  target_path = File.join(PROJECT_ROOT_PATH, 'fixtures', path)
+  FileUtils.cp_r(target_path, expand_path("."))
+
+  step %Q{I cd to "#{path}"}
+end
+
+Then /^the file "([^\"]*)" has the contents$/ do |path, contents|
+  write_file(path, contents)
+
+  @server_inst.files.poll_once!
+end
+
+Then /^the file "([^\"]*)" is removed$/ do |path|
+  step %Q{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)
+  @modification_times[target] = File.mtime(target)
+end
+
+Then /^the file "([^\"]*)" should not have been updated$/ do |file|
+  target = File.join(expand_path("."), file)
+  expect(File.mtime(target)).to eq(@modification_times[target])
+end
+
+# Provide this Aruba overload in case we're matching something with quotes in it
+Then /^the file "([^"]*)" should contain '([^']*)'$/ do |file, partial_content|
+  expect(file).to have_file_content(Regexp.new(Regexp.escape(partial_content)), true)
+end
+
+And /the file "(.*)" should be gzipped/ do |file|
+  expect(File.binread(File.join(expand_path("."), file), 2)).to eq(['1F8B'].pack('H*'))
+end

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

@@ -0,0 +1,124 @@
+require 'middleman-core/rack'
+require 'rspec/expectations'
+require 'capybara/cucumber'
+
+Given /^a clean server$/ do
+  @initialize_commands = []
+  @activation_commands = []
+end
+
+Given /^"([^\"]*)" feature is "([^\"]*)"$/ do |feature, state|
+  @activation_commands ||= []
+
+  if state == 'enabled'
+    @activation_commands << lambda { activate(feature.to_sym) }
+  end
+end
+
+Given /^"([^\"]*)" feature is "enabled" with "([^\"]*)"$/ do |feature, options_str|
+  @activation_commands ||= []
+
+  options = eval("{#{options_str}}")
+
+  @activation_commands << lambda { activate(feature.to_sym, options) }
+end
+
+Given /^"([^\"]*)" is set to "([^\"]*)"$/ do |variable, value|
+  @initialize_commands ||= []
+  @initialize_commands << lambda {
+    config[variable.to_sym] = value
+  }
+end
+
+Given /^the Server is running$/ do
+  root_dir = File.expand_path(expand_path("."))
+
+  if File.exists?(File.join(root_dir, 'source'))
+    ENV['MM_SOURCE'] = 'source'
+  else
+    ENV['MM_SOURCE'] = ''
+  end
+
+  ENV['MM_ROOT'] = root_dir
+
+  initialize_commands = @initialize_commands || []
+  activation_commands = @activation_commands || []
+
+  @server_inst = ::Middleman::Application.new do
+    config[:watcher_disable] = true
+    config[:show_exceptions] = false
+
+    initialize_commands.each do |p|
+      instance_exec(&p)
+    end
+
+    app.after_configuration_eval do
+      activation_commands.each do |p|
+        config_context.instance_exec(&p)
+      end
+    end
+  end
+
+  Capybara.app = ::Middleman::Rack.new(@server_inst).to_app
+end
+
+Given /^the Server is running at "([^\"]*)"$/ do |app_path|
+  step %Q{a fixture app "#{app_path}"}
+  step %Q{the Server is running}
+end
+
+Given /^a template named "([^\"]*)" with:$/ do |name, string|
+  step %Q{a file named "source/#{name}" with:}, string
+end
+
+When /^I go to "([^\"]*)"$/ do |url|
+  visit(URI.encode(url).to_s)
+end
+
+Then /^going to "([^\"]*)" should not raise an exception$/ do |url|
+  expect{ visit(URI.encode(url).to_s) }.to_not raise_exception
+end
+
+Then /^the content type should be "([^\"]*)"$/ do |expected|
+  expect(page.response_headers['Content-Type']).to start_with expected
+end
+
+Then /^the "([^\"]*)" header should contain "([^\"]*)"$/ do |header, expected|
+  expect(page.response_headers[header]).to include expected
+end
+
+Then /^I should see "([^\"]*)"$/ do |expected|
+  expect(page.body).to include expected
+end
+
+Then /^I should see '([^\']*)'$/ do |expected|
+  expect(page.body).to include expected
+end
+
+Then /^I should see:$/ do |expected|
+  expect(page.body).to include expected
+end
+
+Then /^I should not see "([^\"]*)"$/ do |expected|
+  expect(page.body).not_to include expected
+end
+
+Then /^I should see content matching %r{(.*)}$/ do |expected|
+  expect(page.body).to match(expected)
+end
+
+Then /^I should not see content matching %r{(.*)}$/ do |expected|
+  expect(page.body).to_not match(expected)
+end
+
+Then /^I should not see:$/ do |expected|
+  expect(page.body).not_to include expected
+end
+
+Then /^the status code should be "([^\"]*)"$/ do |expected|
+  expect(page.status_code).to eq expected.to_i
+end
+
+Then /^I should see "([^\"]*)" lines$/ do |lines|
+  expect(page.body.chomp.split($/).length).to eq lines.to_i
+end

data/lib/middleman-core/template_context.rb

@@ -0,0 +1,204 @@
+require 'pathname'
+require 'middleman-core/file_renderer'
+require 'middleman-core/template_renderer'
+require 'middleman-core/contracts'
+
+module Middleman
+  # The TemplateContext Class
+  #
+  # A clean context, separate from Application, in which templates can be executed.
+  # All helper methods and values available in a template, but be accessible here.
+  # Also implements two helpers: wrap_layout & render (used by padrino's partial method).
+  # A new context is created for each render of a path, but that context is shared through
+  # the request, passed from template, to layouts and partials.
+  class TemplateContext
+    extend Forwardable
+    include Contracts
+
+    # Allow templates to directly access the current app instance.
+    # @return [Middleman::Application]
+    attr_reader :app
+
+    # Required for Padrino's rendering
+    attr_accessor :current_engine
+
+    # Shorthand references to global values on the app instance.
+    def_delegators :@app, :config, :logger, :sitemap, :server?, :build?, :environment?, :data, :extensions, :root
+
+    # 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={})
+      @app = app
+      @locs = locs
+      @opts = opts
+    end
+
+    # Return the current buffer to the caller and clear the value internally.
+    # Used when moving between templates when rendering layouts or partials.
+    #
+    # @api private
+    # @return [String] The old buffer.
+    def save_buffer
+      @_out_buf, buf_was = '', @_out_buf
+      buf_was
+    end
+
+    # Restore a previously saved buffer.
+    #
+    # @api private
+    # @param [String] buf_was
+    # @return [void]
+    def restore_buffer(buf_was)
+      @_out_buf = buf_was
+    end
+
+    # Allow layouts to be wrapped in the contents of other layouts.
+    #
+    # @param [String, Symbol] layout_name
+    # @return [void]
+    def wrap_layout(layout_name, &block)
+      # Save current buffer for later
+      buf_was = save_buffer
+
+      # Find a layout for this file
+      layout_file = ::Middleman::TemplateRenderer.locate_layout(@app, layout_name, current_engine)
+
+      # Get the layout engine
+      extension = File.extname(layout_file[:relative_path])
+      engine = extension[1..-1].to_sym
+
+      # Store last engine for later (could be inside nested renders)
+      self.current_engine = engine
+      engine_was = current_engine
+
+      # By default, no content is captured
+      content = ''
+
+      # Attempt to capture HTML from block
+      begin
+        content = capture_html(&block) if block_given?
+      ensure
+        # Reset stored buffer, regardless of success
+        restore_buffer(buf_was)
+      end
+      # Render the layout, with the contents of the block inside.
+      concat_safe_content render_file(layout_file, @locs, @opts) { content }
+    ensure
+      # Reset engine back to template's value, regardless of success
+      self.current_engine = engine_was
+    end
+
+    # Sinatra/Padrino compatible render method signature referenced by some view
+    # helpers. Especially partials.
+    #
+    # @param [String, Symbol] name The partial to render.
+    # @param [Hash] options
+    # @return [String]
+    Contract Any, Or[Symbol, String], Hash => String
+    def render(_, name, options={}, &block)
+      name = name.to_s
+
+      partial_file = locate_partial(name, false) || locate_partial(name, true)
+
+      return '' unless partial_file
+      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)
+
+      if (r && !r.template?) || (Tilt[partial_file[:full_path]].nil? && partial_file[:full_path].exist?)
+        partial_file.read
+      else
+        opts = options.dup
+        locs = opts.delete(:locals)
+
+        render_file(partial_file, locs, opts, &block)
+      end
+    end
+
+    # Locate a partial relative to the current path or the source dir, given a partial's path.
+    #
+    # @api private
+    # @param [String] partial_path
+    # @return [String]
+    Contract String, Maybe[Bool] => Maybe[IsA['Middleman::SourceFile']]
+    def locate_partial(partial_path, try_static=true)
+      return unless resource = sitemap.find_resource_by_destination_path(current_path)
+
+      # Look for partials relative to the current path
+      current_dir = resource.file_descriptor[:relative_path].dirname
+      non_root = partial_path.to_s.sub(/^\//, '')
+      relative_dir = current_dir + Pathname(non_root)
+
+      non_root_no_underscore = non_root.sub(/^_/, '').sub(/\/_/, '/')
+      relative_dir_no_underscore = current_dir + Pathname(non_root_no_underscore)
+
+      partial_file = nil
+
+      [
+        [relative_dir.to_s, { preferred_engine: resource.file_descriptor[:relative_path].extname[1..-1].to_sym }],
+        [non_root],
+        [non_root, { try_static: try_static }],
+        [relative_dir_no_underscore.to_s, { try_static: try_static }],
+        [non_root_no_underscore, { try_static: try_static }]
+      ].each do |args|
+        partial_file = ::Middleman::TemplateRenderer.resolve_template(@app, *args)
+        break if partial_file
+      end
+
+      partial_file || nil
+    end
+
+    def current_path
+      @locs[:current_path]
+    end
+
+    # Get the resource object for the current path
+    # @return [Middleman::Sitemap::Resource]
+    def current_resource
+      return nil unless current_path
+      sitemap.find_resource_by_destination_path(current_path)
+    end
+    alias current_page current_resource
+
+    protected
+
+    # Render a path with locs, opts and contents block.
+    #
+    # @api private
+    # @param [Middleman::SourceFile] file The file.
+    # @param [Hash] locs Template locals.
+    # @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
+    def render_file(file, locs, opts, &block)
+      _render_with_all_renderers(file[:relative_path].to_s, locs, self, opts, &block)
+    end
+
+    Contract String, Hash, Any, Hash, Maybe[Proc] => String
+    def _render_with_all_renderers(path, locs, context, opts, &block)
+      # Keep rendering template until we've used up all extensions. This
+      # handles cases like `style.css.sass.erb`
+      content = nil
+
+      while ::Tilt[path]
+        begin
+          opts[:template_body] = content if content
+
+          content_renderer = ::Middleman::FileRenderer.new(@app, path)
+          content = content_renderer.render(locs, opts, context, &block)
+
+          path = File.basename(path, File.extname(path))
+        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
+      end
+
+      content
+    end
+  end
+end

data/lib/middleman-core/template_renderer.rb

@@ -0,0 +1,241 @@
+require 'tilt'
+require 'active_support/core_ext/string/output_safety'
+require 'middleman-core/template_context'
+require 'middleman-core/file_renderer'
+require 'middleman-core/contracts'
+
+module Middleman
+  class TemplateRenderer
+    extend Forwardable
+    include Contracts
+
+    class Cache
+      def initialize
+        @cache = {}
+      end
+
+      def fetch(*key)
+        @cache[key] = yield unless @cache.key?(key)
+        @cache[key]
+      end
+
+      def clear
+        @cache = {}
+      end
+    end
+
+    def self.cache
+      @_cache ||= Cache.new
+    end
+
+    # Find a layout on-disk, optionally using a specific engine
+    # @param [String] name
+    # @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)
+      resolve_opts = {}
+      resolve_opts[:preferred_engine] = preferred_engine unless preferred_engine.nil?
+
+      # Check layouts folder
+      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
+
+      # Return the path
+      layout_file
+    end
+
+    # Find a template on disk given a output path
+    # @param [String] request_path
+    # @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={})
+      # Find the path by searching
+      relative_path = Util.strip_leading_slash(request_path.to_s)
+
+      # By default, any engine will do
+      preferred_engines = []
+
+      # If we're specifically looking for a preferred engine
+      if options.key?(:preferred_engine)
+        extension_class = ::Tilt[options[:preferred_engine]]
+
+        # Get a list of extensions for a preferred engine
+        preferred_engines += ::Tilt.mappings.select do |_, engines|
+          engines.include? extension_class
+        end.keys
+      end
+
+      preferred_engines << '*'
+      preferred_engines << nil if options[:try_static]
+
+      found_template = nil
+
+      preferred_engines.each do |preferred_engine|
+        path_with_ext = relative_path.dup
+        path_with_ext << ('.' + preferred_engine) unless preferred_engine.nil?
+
+        globbing = preferred_engine == '*'
+
+        # 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
+
+        found_template = file if file && (preferred_engine.nil? || ::Tilt[file[:full_path]])
+        break if found_template
+      end
+
+      # If we found one, return it
+      found_template
+    end
+
+    # Custom error class for handling
+    class TemplateNotFound < RuntimeError; end
+
+    def initialize(app, path)
+      @app = app
+      @path = path
+    end
+
+    # Render a template, with layout, given a path
+    #
+    # @param [Hash] locs
+    # @param [Hash] opts
+    # @return [String]
+    Contract Hash, Hash => String
+    def render(locs={}, opts={}, &block)
+      path = @path.dup
+      locals = locs.dup.freeze
+      options = opts.dup
+
+      extension = File.extname(path)
+      engine = extension[1..-1].to_sym
+
+      if defined?(::I18n)
+        old_locale = ::I18n.locale
+        ::I18n.locale = options[:locale] if options[:locale]
+
+        # Backwards compat
+        ::I18n.locale = options[:lang] if options[:lang]
+      end
+
+      # Sandboxed class for template eval
+      context = @app.template_context_class.new(@app, locals, options)
+
+      # Add extension helpers to context.
+      @app.extensions.add_exposed_to_context(context)
+
+      content = ::Middleman::Util.instrument 'builder.output.resource.render-template', path: File.basename(path) do
+        _render_with_all_renderers(path, locs, context, opts, &block)
+      end
+
+      # If we need a layout and have a layout, use it
+      layout_file = fetch_layout(engine, options)
+      if layout_file
+        content = ::Middleman::Util.instrument 'builder.output.resource.render-layout', path: File.basename(layout_file[:relative_path].to_s) do
+          if layout_file = fetch_layout(engine, options)
+            layout_renderer = ::Middleman::FileRenderer.new(@app, layout_file[:relative_path].to_s)
+            layout_renderer.render(locals, options, context) { content }
+          else
+            content
+          end
+        end
+      end
+
+      # Return result
+      content
+    ensure
+      # Pop all the saved variables from earlier as we may be returning to a
+      # previous render (layouts, partials, nested layouts).
+      ::I18n.locale = old_locale if defined?(::I18n)
+    end
+
+    protected
+
+    def _render_with_all_renderers(path, locs, context, opts, &block)
+      # Keep rendering template until we've used up all extensions. This
+      # handles cases like `style.css.sass.erb`
+      content = nil
+
+      while ::Tilt[path]
+        begin
+          opts[:template_body] = content if content
+
+          content_renderer = ::Middleman::FileRenderer.new(@app, path)
+          content = content_renderer.render(locs, opts, context, &block)
+
+          path = File.basename(path, File.extname(path))
+        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
+      end
+
+      content
+    end
+
+    # Find a layout for a given engine
+    #
+    # @param [Symbol] engine
+    # @param [Hash] opts
+    # @return [String, Boolean]
+    Contract Symbol, Hash => Maybe[IsA['Middleman::SourceFile']]
+    def fetch_layout(engine, opts)
+      # The layout name comes from either the system default or the options
+      local_layout = opts.key?(:layout) ? opts[:layout] : @app.config[:layout]
+      return unless local_layout
+
+      # Look for engine-specific options
+      engine_options = @app.config.respond_to?(engine) ? @app.config.send(engine) : {}
+
+      # 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
+
+      # 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.
+
+        layout_file
+      else
+        raise ::Middleman::TemplateRenderer::TemplateNotFound, "Could not locate layout: #{local_layout}"
+      end
+    end
+
+    # Find a layout on-disk, optionally using a specific engine
+    # @param [String] name
+    # @param [Symbol] preferred_engine
+    # @return [String]
+    Contract Or[String, Symbol], Symbol => Maybe[IsA['Middleman::SourceFile']]
+    def locate_layout(name, preferred_engine=nil)
+      self.class.locate_layout(@app, name, preferred_engine)
+    end
+
+    # Find a template on disk given a output path
+    # @param [String] request_path
+    # @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)
+    end
+  end
+end