middleman-core 3.3.12 → 3.4.0

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

@@ -0,0 +1,18 @@
+module Middleman
+  class PreviewServer
+    # Validate user input
+    class ServerInformationValidator
+      # Validate the input
+      #
+      # @param [ServerInformation] information
+      #   The information instance which holds information about the preview
+      #   server settings
+      #
+      # @param [Array] checks
+      #   A list of checks which should be evaluated
+      def validate(information, checks)
+        checks.each { |c| c.validate information }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require 'ipaddr'
+require 'forwardable'
+
+module Middleman
+  class PreviewServer
+    class ServerIpAddress
+      def self.new(ip_address)
+        @parser = []
+        @parser << ServerIpv6Address
+        @parser << ServerIpv4Address
+
+        @parser.find { |p| p.match? ip_address }.new(ip_address)
+      end
+    end
+
+    class BasicServerIpAddress < SimpleDelegator
+    end
+
+    class ServerIpv4Address < BasicServerIpAddress
+      def to_browser
+        __getobj__.to_s
+      end
+
+      def self.match?(*)
+        true
+      end
+    end
+
+    class ServerIpv6Address < BasicServerIpAddress
+      def to_s
+        __getobj__.sub(/%.*$/, '')
+      end
+
+      def to_browser
+        format('[%s]', to_s)
+      end
+
+      if RUBY_VERSION < '2'
+        def self.match?(str)
+          str = str.to_s.sub(/%.*$/, '')
+          IPAddr.new(str).ipv6?
+        rescue StandardError
+          false
+        end
+      else
+        def self.match?(str)
+          str = str.to_s.sub(/%.*$/, '')
+          IPAddr.new(str).ipv6?
+        rescue IPAddr::InvalidAddressError, IPAddr::AddressFamilyError
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'ipaddr'
+
+module Middleman
+  class PreviewServer
+    # This builds the server urls for the preview server
+    class ServerUrl
+      private
+
+      attr_reader :hosts, :port, :https
+
+      public
+
+      def initialize(opts={})
+        @hosts = opts.fetch(:hosts)
+        @port  = opts.fetch(:port)
+        @https = opts.fetch(:https, false)
+      end
+
+      # Return bind addresses
+      #
+      # @return [Array]
+      #   List of bind addresses of format host:port
+      def to_bind_addresses
+        hosts.map { |l| format('"%s:%s"', l.to_s, port) }
+      end
+
+      # Return server urls
+      #
+      # @return [Array]
+      #   List of urls of format http://host:port
+      def to_urls
+        hosts.map { |l| format('"%s://%s:%s"', https? ? 'https' : 'http', l.to_browser, port) }
+      end
+
+      # Return server config urls
+      #
+      # @return [Array]
+      #   List of urls of format http://host:port/__middleman
+      def to_config_urls
+        hosts.map { |l| format('"%s://%s:%s/__middleman"', https? ? 'https' : 'http', l.to_browser, port) }
+      end
+
+      private
+
+      def https?
+        https == true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Middleman
+  class PreviewServer
+    # Probe for tcp ports
+    #
+    # This one first tries `try_port` if this is not available use the free
+    # port returned by TCPServer.
+    class TcpPortProber
+      # Check for port
+      #
+      # @param [Integer] try_port
+      #   The port to be checked
+      #
+      # @return [Integer]
+      #   The port
+      def port(try_port)
+        server = TCPServer.open(try_port)
+        server.close
+
+        try_port
+      rescue
+        server = TCPServer.open(0)
+        port = server.addr[1]
+        server.close
+
+        port
+      end
+    end
+  end
+end

data/lib/middleman-core/sitemap.rb

@@ -28,16 +28,16 @@ module Middleman
           root_dotfiles: proc { |file| file.start_with?('.') },
 
           # Files starting with an dot, but not .htaccess
-          source_dotfiles: proc { |file|
+          source_dotfiles: proc do |file|
             file =~ %r{/\.} && file !~ %r{/\.(htaccess|htpasswd|nojekyll)}
-          },
+          end,
 
           # Files starting with an underscore, but not a double-underscore
           partials: proc { |file| file =~ %r{/_[^_]} },
 
-          layout: proc { |file, sitemap_app|
+          layout: proc do |file, sitemap_app|
             file.start_with?(File.join(sitemap_app.config[:source], 'layout.')) || file.start_with?(File.join(sitemap_app.config[:source], 'layouts/'))
-          }
+          end
         }, 'Callbacks that can exclude paths from the sitemap'
 
         # Include instance methods

data/lib/middleman-core/sitemap/extensions/ignores.rb

@@ -59,7 +59,11 @@ module Middleman
             elsif path.is_a? String
               path_clean = ::Middleman::Util.normalize_path(path)
               if path_clean.include?('*') # It's a glob
-                @ignored_callbacks << proc { |p| File.fnmatch(path_clean, p) }
+                if defined? File::FNM_EXTGLOB
+                  @ignored_callbacks << proc { |p| File.fnmatch(path_clean, p, File::FNM_EXTGLOB) }
+                else
+                  @ignored_callbacks << proc { |p| File.fnmatch(path_clean, p) }
+                end
               else
                 # Add a specific-path ignore unless that path is already covered
                 return if ignored?(path_clean)

data/lib/middleman-core/sitemap/extensions/proxies.rb

@@ -17,7 +17,6 @@ module Middleman
 
         module ResourceInstanceMethods
           # Whether this page is a proxy
-          # rubocop:disable TrivialAccessors
           # @return [Boolean]
           def proxy?
             @proxied_to

data/lib/middleman-core/sitemap/extensions/redirects.rb

@@ -80,7 +80,7 @@ module Middleman
             url = ::Middleman::Util.url_for(store.app, @request_path,
                                             relative: false,
                                             find_resource: true
-            )
+                                           )
 
             if output
               output.call(path, url)
@@ -88,6 +88,7 @@ module Middleman
               <<-END
                 <html>
                   <head>
+                    <link rel="canonical" href="#{url}" />
                     <meta http-equiv=refresh content="0; url=#{url}" />
                     <meta name="robots" content="noindex,follow" />
                     <meta http-equiv="cache-control" content="no-cache" />

data/lib/middleman-core/sitemap/queryable.rb

@@ -125,7 +125,8 @@ module Middleman
           unless VALID_OPERATORS.include? opts[:operator]
             raise OperatorNotSupportedError
           end
-          @attribute, @operator = opts[:attribute], opts[:operator]
+          @attribute = opts[:attribute]
+          @operator = opts[:operator]
         end
       end
     end

data/lib/middleman-core/sitemap/store.rb

@@ -231,10 +231,10 @@ module Middleman
       private
 
       def reset_lookup_cache!
-        @lock.synchronize {
+        @lock.synchronize do
           @_lookup_by_path = {}
           @_lookup_by_destination_path = {}
-        }
+        end
       end
 
       # Removes the templating extensions, while keeping the others
@@ -242,7 +242,7 @@ module Middleman
       # @return [String]
       def remove_templating_extensions(path)
         # Strip templating extensions as long as Tilt knows them
-        path = path.sub(File.extname(path), '') while ::Tilt[path]
+        path = path.sub(/#{::Regexp.escape(File.extname(path))}$/, '') while ::Tilt[path]
         path
       end
 

data/lib/middleman-core/step_definitions.rb

@@ -3,6 +3,7 @@ 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

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

@@ -6,8 +6,8 @@ end
 
 Given /^app "([^\"]*)" is using config "([^\"]*)"$/ do |path, config_name|
   target = File.join(PROJECT_ROOT_PATH, 'fixtures', path)
-  config_path = File.join(current_dir, "config-#{config_name}.rb")
-  config_dest = File.join(current_dir, 'config.rb')
+  config_path = File.join(current_directory, "config-#{config_name}.rb")
+  config_dest = File.join(current_directory, 'config.rb')
   FileUtils.cp(config_path, config_dest)
 end
 
@@ -22,12 +22,12 @@ 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(current_dir) == path
+  next if File.basename(current_directory) == path
 
   step %Q{a directory named "#{path}"}
 
   target_path = File.join(PROJECT_ROOT_PATH, 'fixtures', path)
-  FileUtils.cp_r(target_path, current_dir)
+  FileUtils.cp_r(target_path, current_directory)
 
   step %Q{I cd to "#{path}"}
 end
@@ -58,12 +58,12 @@ Given /^a successfully built app at "([^\"]*)" with flags "([^\"]*)"$/ do |path,
 end
 
 Given /^a modification time for a file named "([^\"]*)"$/ do |file|
-  target = File.join(current_dir, file)
+  target = File.join(current_directory, file)
   @modification_times[target] = File.mtime(target)
 end
 
 Then /^the file "([^\"]*)" should not have been updated$/ do |file|
-  target = File.join(current_dir, file)
+  target = File.join(current_directory, file)
   File.mtime(target).should == @modification_times[target]
 end
 
@@ -73,5 +73,5 @@ Then /^the file "([^"]*)" should contain '([^']*)'$/ do |file, partial_content|
 end
 
 And /the file "(.*)" should be gzipped/ do |file|
-  expect(File.binread(File.join(current_dir, file), 2)).to eq(['1F8B'].pack('H*'))
+  expect(File.binread(File.join(current_directory, file), 2)).to eq(['1F8B'].pack('H*'))
 end

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

@@ -0,0 +1,88 @@
+When /^I stop (?:middleman|all commands) if the output( of the last command)? contains:$/ do |last_command, expected|
+  begin
+    Timeout.timeout(exit_timeout) do
+      loop do
+        fail "You need to start middleman interactively first." unless @interactive
+
+        if unescape(@interactive.output) =~ Regexp.new(unescape(expected))
+          only_processes.each { |p| p.terminate }
+          break
+        end
+
+        sleep 0.1
+      end
+    end
+  rescue ChildProcess::TimeoutError, TimeoutError
+    @interactive.terminate
+  ensure
+    announcer.stdout @interactive.stdout
+    announcer.stderr @interactive.stderr
+  end
+end
+
+# Make it just a long running process
+Given /`(.*?)` is running in background/ do |cmd|
+  run(cmd, 120)
+end
+
+Given /I have a local hosts file with:/ do |string|
+  step 'I set the environment variables to:', table(
+    %(
+      | variable | value  |
+      | MM_HOSTSRC  | .hosts |
+    )
+  )
+
+  step 'a file named ".hosts" with:', string
+end
+
+Given /I start a dns server with:/ do |string|
+  @dns_server.terminate if defined? @dns_server
+
+  port = 5300
+  db_file = 'dns.db'
+
+  step 'I set the environment variables to:', table(
+    %(
+       | variable  | value            |
+       | MM_DNSRC  | 127.0.0.1:#{port}|
+    )
+  )
+
+  set_env 'PATH', File.expand_path(File.join(current_dir, 'bin')) + ':' + ENV['PATH']
+  write_file db_file, string
+
+  @dns_server = run("dns_server.rb #{db_file} #{port}", 120)
+end
+
+Given /I start a mdns server with:/ do |string|
+  @mdns_server.terminate if defined? @mdns_server
+
+  port = 5301
+  db_file = 'mdns.db'
+
+  step 'I set the environment variables to:', table(
+    %(
+       | variable  | value             |
+       | MM_MDNSRC  | 127.0.0.1:#{port}|
+    )
+  )
+
+  set_env 'PATH', File.expand_path(File.join(current_dir, 'bin')) + ':' + ENV['PATH']
+  write_file db_file, string
+
+  @mdns_server = run("dns_server.rb #{db_file} #{port}", 120)
+end
+
+Given /I start a mdns server for the local hostname/ do
+  step %(I start a mdns server with:), "#{Socket.gethostname}: 127.0.0.1"
+end
+
+# Make sure each and every process is really dead
+After do
+  only_processes.each { |p| p.terminate }
+end
+
+Before '@ruby-2.1' do
+  skip_this_scenario if RUBY_VERSION < '2.1'
+end

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

@@ -1,6 +1,5 @@
-# encoding: UTF-8
-
-require 'rack/test'
+require 'rspec/expectations'
+require 'capybara/cucumber'
 
 Given /^a clean server$/ do
   @initialize_commands = []
@@ -32,8 +31,7 @@ Given /^current environment is "([^\"]*)"$/ do |env|
 end
 
 Given /^the Server is running$/ do
-  root_dir = File.expand_path(current_dir)
-
+  root_dir = File.expand_path(current_directory)
 
   if File.exists?(File.join(root_dir, 'source'))
     ENV['MM_SOURCE'] = 'source'
@@ -49,7 +47,7 @@ Given /^the Server is running$/ do
     set :show_exceptions, false
   }
 
-  in_current_dir do
+  in_current_directory do
     @server_inst = Middleman::Application.server.inst do
       initialize_commands.each do |p|
         instance_exec(&p)
@@ -57,8 +55,7 @@ Given /^the Server is running$/ do
     end
   end
 
-  app_rack = @server_inst.class.to_rack_app
-  @browser = ::Rack::Test::Session.new(::Rack::MockSession.new(app_rack))
+  Capybara.app =  @server_inst.class.to_rack_app
 end
 
 Given /^the Server is running at "([^\"]*)"$/ do |app_path|
@@ -71,61 +68,61 @@ Given /^a template named "([^\"]*)" with:$/ do |name, string|
 end
 
 When /^I go to "([^\"]*)"$/ do |url|
-  in_current_dir do
-    @browser.get(URI.encode(url))
+  in_current_directory do
+    visit(URI.encode(url).to_s)
   end
 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
+  in_current_directory do
+    expect{ visit(URI.encode(url).to_s) }.to_not raise_exception
   end
 end
 
 Then /^the content type should be "([^\"]*)"$/ do |expected|
-  in_current_dir do
-    expect(@browser.last_response.content_type).to start_with(expected)
+  in_current_directory do
+    expect(page.response_headers['Content-Type']).to start_with expected
   end
 end
 
 Then /^I should see "([^\"]*)"$/ do |expected|
-  in_current_dir do
-    expect(@browser.last_response.body).to include(expected)
+  in_current_directory do
+    expect(page.body).to include expected
   end
 end
 
 Then /^I should see '([^\']*)'$/ do |expected|
-  in_current_dir do
-    expect(@browser.last_response.body).to include(expected)
+  in_current_directory do
+    expect(page.body).to include expected
   end
 end
 
 Then /^I should see:$/ do |expected|
-  in_current_dir do
-    expect(@browser.last_response.body).to include(expected)
+  in_current_directory do
+    expect(page.body).to include expected
   end
 end
 
 Then /^I should not see "([^\"]*)"$/ do |expected|
-  in_current_dir do
-    expect(@browser.last_response.body).to_not include(expected)
+  in_current_directory do
+    expect(page.body).not_to include expected
   end
 end
 
 Then /^I should not see:$/ do |expected|
-  in_current_dir do
-    expect(@browser.last_response.body).to_not include(expected.chomp)
+  in_current_directory do
+    expect(page.body).not_to include expected
   end
 end
 
 Then /^the status code should be "([^\"]*)"$/ do |expected|
-  in_current_dir do
-    expect(@browser.last_response.status).to eq expected.to_i
+  in_current_directory do
+    expect(page.status_code).to eq expected.to_i
   end
 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)
+  in_current_directory do
+    expect(page.body.chomp.split($/).length).to eq lines.to_i
   end
 end