middleman-core 3.3.12 → 4.4.2

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

@@ -1,39 +1,38 @@
-# encoding: UTF-8
-
-require 'rack/test'
+require 'middleman-core/rack'
+require 'rspec/expectations'
+require 'capybara/cucumber'
+require 'webrick'
 
 Given /^a clean server$/ do
   @initialize_commands = []
+  @activation_commands = []
 end
 
 Given /^"([^\"]*)" feature is "([^\"]*)"$/ do |feature, state|
-  @initialize_commands ||= []
+  @activation_commands ||= []
 
   if state == 'enabled'
-    @initialize_commands << lambda { activate(feature.to_sym) }
+    @activation_commands << lambda { activate(feature.to_sym) }
   end
 end
 
 Given /^"([^\"]*)" feature is "enabled" with "([^\"]*)"$/ do |feature, options_str|
-  @initialize_commands ||= []
+  @activation_commands ||= []
 
   options = eval("{#{options_str}}")
 
-  @initialize_commands << lambda { activate(feature.to_sym, options) }
+  @activation_commands << lambda { activate(feature.to_sym, options) }
 end
 
 Given /^"([^\"]*)" is set to "([^\"]*)"$/ do |variable, value|
   @initialize_commands ||= []
-  @initialize_commands << lambda { set(variable.to_sym, value) }
-end
-
-Given /^current environment is "([^\"]*)"$/ do |env|
-  @current_env = env.to_sym
+  @initialize_commands << lambda {
+    config[variable.to_sym] = value
+  }
 end
 
 Given /^the Server is running$/ do
-  root_dir = File.expand_path(current_dir)
-
+  root_dir = File.expand_path(expand_path("."))
 
   if File.exists?(File.join(root_dir, 'source'))
     ENV['MM_SOURCE'] = 'source'
@@ -44,21 +43,24 @@ Given /^the Server is running$/ do
   ENV['MM_ROOT'] = root_dir
 
   initialize_commands = @initialize_commands || []
-  initialize_commands.unshift lambda {
-    set :environment, @current_env || :development
-    set :show_exceptions, false
-  }
+  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
 
-  in_current_dir do
-    @server_inst = Middleman::Application.server.inst do
-      initialize_commands.each do |p|
-        instance_exec(&p)
+    app.after_configuration_eval do
+      activation_commands.each do |p|
+        config_context.instance_exec(&p)
       end
     end
   end
 
-  app_rack = @server_inst.class.to_rack_app
-  @browser = ::Rack::Test::Session.new(::Rack::MockSession.new(app_rack))
+  Capybara.app = ::Middleman::Rack.new(@server_inst).to_app
 end
 
 Given /^the Server is running at "([^\"]*)"$/ do |app_path|
@@ -71,61 +73,53 @@ Given /^a template named "([^\"]*)" with:$/ do |name, string|
 end
 
 When /^I go to "([^\"]*)"$/ do |url|
-  in_current_dir do
-    @browser.get(URI.encode(url))
-  end
+  visit(WEBrick::HTTPUtils.escape(url))
 end
 
 Then /^going to "([^\"]*)" should not raise an exception$/ do |url|
-  in_current_dir do
-    expect{ @browser.get(URI.encode(url)) }.to_not raise_exception
-  end
+  expect{ visit(WEBrick::HTTPUtils.escape(url)) }.to_not raise_exception
 end
 
 Then /^the content type should be "([^\"]*)"$/ do |expected|
-  in_current_dir do
-    expect(@browser.last_response.content_type).to start_with(expected)
-  end
+  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|
-  in_current_dir do
-    expect(@browser.last_response.body).to include(expected)
-  end
+  expect(page.body).to include expected
 end
 
 Then /^I should see '([^\']*)'$/ do |expected|
-  in_current_dir do
-    expect(@browser.last_response.body).to include(expected)
-  end
+  expect(page.body).to include expected
 end
 
 Then /^I should see:$/ do |expected|
-  in_current_dir do
-    expect(@browser.last_response.body).to include(expected)
-  end
+  expect(page.body).to include expected
 end
 
 Then /^I should not see "([^\"]*)"$/ do |expected|
-  in_current_dir do
-    expect(@browser.last_response.body).to_not include(expected)
-  end
+  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|
-  in_current_dir do
-    expect(@browser.last_response.body).to_not include(expected.chomp)
-  end
+  expect(page.body).not_to include expected
 end
 
 Then /^the status code should be "([^\"]*)"$/ do |expected|
-  in_current_dir do
-    expect(@browser.last_response.status).to eq expected.to_i
-  end
+  expect(page.status_code).to eq expected.to_i
 end
 
 Then /^I should see "([^\"]*)" lines$/ do |lines|
-  in_current_dir do
-    expect(@browser.last_response.body.chomp.split($/).length).to eq(lines.to_i)
-  end
+  expect(page.body.chomp.split($/).length).to eq lines.to_i
 end

data/lib/middleman-core/step_definitions.rb

@@ -1,14 +1,14 @@
 require 'aruba/cucumber'
-require 'aruba/jruby'
 require 'middleman-core/step_definitions/middleman_steps'
 require 'middleman-core/step_definitions/builder_steps'
 require 'middleman-core/step_definitions/server_steps'
+require 'middleman-core/step_definitions/commandline_steps'
 
 # Monkeypatch for windows support
 module ArubaMonkeypatch
   def detect_ruby(cmd)
     if cmd.start_with?('middleman ') && Gem.win_platform?
-      "#{current_ruby} #{Dir.pwd}/bin/#{cmd}"
+      "#{current_ruby} #{Dir.pwd}/../middleman-cli/bin/#{cmd}"
     else
       cmd.sub(/^ruby(?= )/, current_ruby)
     end

data/lib/middleman-core/template_context.rb

@@ -0,0 +1,213 @@
+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?, :environment, :data, :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={})
+      @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
+    # @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)
+      name = name.to_s
+
+      partial_file = locate_partial(name, false) || locate_partial(name, true)
+
+      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 = locals.dup
+
+        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)
+      partial_file = nil
+      lookup_stack = []
+      non_root     = partial_path.to_s.sub(/^\//, '')
+      non_root_no_underscore = non_root.sub(/^_/, '').sub(/\/_/, '/')
+
+      if 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 }]
+      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 }]
+
+      lookup_stack.each do |args|
+        partial_file = ::Middleman::TemplateRenderer.resolve_template(@app, *args)
+        break if partial_file
+      end
+
+      partial_file
+    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 ::Middleman::Util.tilt_class(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,252 @@
+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 = ::Middleman::Util.tilt_class(options[: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]
+
+      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? || ::Middleman::Util.tilt_class(file[:full_path].to_s))
+        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)
+
+      locals.each do |k, _|
+        next unless context.respond_to?(k) && ![: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`"
+
+        if @app.build?
+          throw msg
+        else
+          @app.logger.error(msg)
+        end
+      end
+
+      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
+      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 ::Middleman::Util.tilt_class(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