middleman-core 4.0.0.rc.1 → 4.0.0.rc.2

data/lib/middleman-core/util/data.rb

@@ -1,153 +1,102 @@
-# Core Pathname library used for traversal
+require 'yaml'
+require 'json'
 require 'pathname'
-
-# DbC
-require 'middleman-core/contracts'
-
-# Shared util methods
 require 'middleman-core/util'
+require 'middleman-core/contracts'
+require 'backports/2.1.0/array/to_h'
 
-# Parsing YAML data
-require 'yaml'
-
-# Parsing JSON data
-require 'active_support/json'
-
-module Middleman
-  module Util
-    module Data      
-      include Contracts
-
-      module_function
-
-      YAML_ERRORS = [StandardError]
-
-      # https://github.com/tenderlove/psych/issues/23
-      if defined?(Psych) && defined?(Psych::SyntaxError)
-        YAML_ERRORS << Psych::SyntaxError
-      end
-
-      # Get the frontmatter and plain content from a file
-      # @param [String] path
-      # @return [Array<Hash, String>]
-      Contract Pathname, Maybe[Symbol] => [Hash, Maybe[String]]
-      def parse(full_path, known_type=nil)
-        data = {}
-
-        return [data, nil] if ::Middleman::Util.binary?(full_path)
-
-        # Avoid weird race condition when a file is renamed.
-        content = begin
-          File.read(full_path)
-        rescue ::EOFError
-        rescue ::IOError
-        rescue ::Errno::ENOENT
-          ''
-        end
-
-        begin
-          if content =~ /\A.*coding:/
-            lines = content.split(/\n/)
-            lines.shift
-            content = lines.join("\n")
-          end
-
-          if known_type
-            if known_type == :yaml
-              result = parse_yaml(content, full_path, true)
-            elsif known_type == :json
-              result = parse_json(content, full_path)
-            end
-          else
-            result = parse_yaml(content, full_path, false)
-          end
-
-          return result if result
-        rescue
-          # Probably a binary file, move on
-        end
-
-        [data, content]
-      end
-
-      # Parse YAML frontmatter out of a string
-      # @param [String] content
-      # @return [Array<Hash, String>]
-      Contract String, Pathname, Bool => Maybe[[Hash, String]]
-      def parse_yaml(content, full_path, require_yaml=false)
-        total_delims = content.scan(/^(?:---|\.\.\.)\s*(?:\n|$)/).length
-        has_first_line_delim = !content.match(/\A(---\s*(?:\n|$))/).nil?
-        # has_closing_delim = (total_delims > 1 && has_first_line_delim) || (!has_first_line_delim && total_delims == 1)
-
-        parts = content.split(/^(?:---|\.\.\.)\s*(?:\n|$)/)
-        parts.shift if parts[0].empty?
-
-        yaml_string = nil
-        additional_content = nil
+module Middleman::Util::Data
+  include Contracts
 
-        if require_yaml
-          yaml_string = parts[0]
-          additional_content = parts[1]
-        else
-          if total_delims > 1
-            if has_first_line_delim
-              yaml_string = parts[0]
-              additional_content = parts[1]
-            else
-              additional_content = content
-            end
-          else
-            additional_content = parts[0]
-          end
-        end
+  module_function
 
-        return [{}, additional_content] if yaml_string.nil?
+  # Get the frontmatter and plain content from a file
+  # @param [String] path
+  # @return [Array<Hash, String>]
+  Contract Pathname, Maybe[Symbol] => [Hash, Maybe[String]]
+  def parse(full_path, frontmatter_delims, known_type=nil)
+    return [{}, nil] if Middleman::Util.binary?(full_path)
 
-        begin
-          data = map_value(::YAML.load(yaml_string) || {})
-        rescue *YAML_ERRORS => e
-          $stderr.puts "YAML Exception parsing #{full_path}: #{e.message}"
-          return nil
-        end
+    # Avoid weird race condition when a file is renamed
+    begin
+      content = File.read(full_path)
+    rescue EOFError, IOError, Errno::ENOENT
+      return [{}, nil]
+    end
 
-        [data, additional_content]
-      rescue
-        [{}, additional_content]
+    start_delims, stop_delims = frontmatter_delims
+                                .values
+                                .flatten(1)
+                                .transpose
+                                .map(&Regexp.method(:union))
+
+    match = /
+      \A(?:[^\r\n]*coding:[^\r\n]*\r?\n)?
+      (?<start>#{start_delims})[ ]*\r?\n
+      (?<frontmatter>.*?)[ ]*\r?\n?
+      ^(?<stop>#{stop_delims})[ ]*\r?\n?
+      \r?\n?
+      (?<additional_content>.*)
+    /mx.match(content) || {}
+
+    unless match[:frontmatter]
+      case known_type
+      when :yaml
+        return [parse_yaml(content, full_path), nil]
+      when :json
+        return [parse_json(content, full_path), nil]
       end
+    end
 
-      # Parse JSON frontmatter out of a string
-      # @param [String] content
-      # @return [Array<Hash, String>]
-      Contract String, Pathname => Maybe[[Hash, String]]
-      def parse_json(content, full_path)
-        begin
-          data = map_value(::ActiveSupport::JSON.decode(content))
-        rescue => e
-          $stderr.puts "JSON Exception parsing #{full_path}: #{e.message}"
-          return nil
-        end
+    case [match[:start], match[:stop]]
+    when *frontmatter_delims[:yaml]
+      [
+        parse_yaml(match[:frontmatter], full_path),
+        match[:additional_content]
+      ]
+    when *frontmatter_delims[:json]
+      [
+        parse_json("{#{match[:frontmatter]}}", full_path),
+        match[:additional_content]
+      ]
+    else
+      [
+        {},
+        content
+      ]
+    end
+  end
 
-        [data, nil]
-      rescue
-        [{}, nil]
-      end
+  # Parse YAML frontmatter out of a string
+  # @param [String] content
+  # @return [Hash]
+  Contract String, Pathname, Bool => Hash
+  def parse_yaml(content, full_path)
+    symbolize_recursive(YAML.load(content) || {})
+  rescue StandardError, Psych::SyntaxError => error
+    warn "YAML Exception parsing #{full_path}: #{error.message}"
+    {}
+  end
 
-      def symbolize_recursive(hash)
-        {}.tap do |h|
-          hash.each { |key, value| h[key.to_sym] = map_value(value) }
-        end
-      end
+  # Parse JSON frontmatter out of a string
+  # @param [String] content
+  # @return [Hash]
+  Contract String, Pathname => Hash
+  def parse_json(content, full_path)
+    symbolize_recursive(JSON.parse(content) || {})
+  rescue StandardError => error
+    warn "JSON Exception parsing #{full_path}: #{error.message}"
+    {}
+  end
 
-      def map_value(thing)
-        case thing
-        when Hash
-          symbolize_recursive(thing)
-        when Array
-          thing.map { |v| map_value(v) }
-        else
-          thing
-        end
-      end
+  def symbolize_recursive(value)
+    case value
+    when Hash
+      value.map { |k, v| [k.to_sym, symbolize_recursive(v)] }.to_h
+    when Array
+      value.map { |v| symbolize_recursive(v) }
+    else
+      value
     end
   end
 end

data/lib/middleman-core/version.rb

@@ -1,5 +1,5 @@
 module Middleman
   # Current Version
   # @return [String]
-  VERSION = '4.0.0.rc.1' unless const_defined?(:VERSION)
+  VERSION = '4.0.0.rc.2' unless const_defined?(:VERSION)
 end

data/middleman-core.gemspec

@@ -16,43 +16,43 @@ Gem::Specification.new do |s|
   s.files        = `git ls-files -z`.split("\0")
   s.test_files   = `git ls-files -z -- {fixtures,features}/*`.split("\0")
   s.require_path = 'lib'
-  s.required_ruby_version = '>= 1.9.3'
+  s.required_ruby_version = '>= 2.0.0'
 
   # Core
   s.add_dependency('bundler', ['~> 1.1'])
-  s.add_dependency('backports', ['~> 3.6'])
   s.add_dependency('rack', ['>= 1.4.5', '< 2.0'])
   s.add_dependency('tilt', ['~> 1.4.1'])
   s.add_dependency('erubis')
 
   # Helpers
-  s.add_dependency('activesupport', ['~> 4.2.0'])
-  s.add_dependency('padrino-helpers', ['~> 0.12.3'])
+  s.add_dependency('activesupport', ['~> 4.2'])
+  s.add_dependency('padrino-helpers', ['~> 0.13.0'])
   s.add_dependency("addressable", ["~> 2.3.5"])
 
   # Watcher
   s.add_dependency('listen', ['~> 3.0'])
 
+  # Tests
+  s.add_dependency("capybara", ["~> 2.5.0"])
+
   # i18n
   s.add_dependency('i18n', ['~> 0.7.0'])
 
   # Automatic Image Sizes
-  s.add_dependency('fastimage', ['~> 1.6.2'])
+  s.add_dependency('fastimage', ['~> 1.8'])
 
   # Minify CSS
-  s.add_dependency('sass', ['>= 3.3.4'])
-
-  # Work around Sass performance
-  s.add_dependency('compass-import-once', ['~> 1.0.4'])
+  s.add_dependency('sass', ['>= 3.4'])
 
   # Minify JS
   s.add_dependency('uglifier', ['~> 2.6'])
   s.add_dependency('execjs', ['~> 2.0'])
 
   # Testing
-  s.add_dependency('contracts', ['~> 0.9.0'])
+  s.add_dependency('contracts', ['~> 0.12.0'])
 
   # Hash stuff
   s.add_dependency('hashie', ['~> 3.4'])
-  s.add_dependency('hamster', ['~> 1.0'])
+  s.add_dependency('hamster', ['~> 2.0'])
+  s.add_dependency('backports', ['~> 3.6'])
 end

data/spec/middleman-core/dns_resolver_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+require 'middleman-core/dns_resolver'
+
+RSpec.describe Middleman::DnsResolver do
+  subject(:resolver) do
+    described_class.new(
+      hosts_resolver: hosts_resolver,
+      local_link_resolver: local_link_resolver,
+      network_resolver: network_resolver
+    )
+  end
+
+  let(:hosts_resolver) { instance_double('Middleman::DnsResolver::HostsResolver') }
+  let(:local_link_resolver) { instance_double('Middleman::DnsResolver::LocalLinkResolver') }
+  let(:network_resolver) { instance_double('Middleman::DnsResolver::NetworkResolver') }
+
+  before :each do
+    allow(network_resolver).to receive(:timeouts=)
+  end
+
+  describe '#names_for' do
+    context 'when hosts resolver can resolve name' do
+      before :each do
+        expect(hosts_resolver).to receive(:getnames).with(unresolved_ip).and_return(resolved_names)
+        if RUBY_VERSION >= '2.1'
+          expect(local_link_resolver).not_to receive(:getnames)
+        end
+        expect(network_resolver).not_to receive(:getnames)
+      end
+
+      let(:unresolved_ip) { '127.0.0.1' }
+      let(:resolved_names) { %w(localhost) }
+
+      it { expect(resolver.names_for(unresolved_ip)).to eq resolved_names }
+    end
+
+    context 'when local link resolver can resolve name' do
+      before :each do
+        expect(hosts_resolver).to receive(:getnames).with(unresolved_ip).and_return([])
+        if RUBY_VERSION >= '2.1'
+          expect(local_link_resolver).to receive(:getnames).with(unresolved_ip).and_return(resolved_names)
+          expect(network_resolver).not_to receive(:getnames)
+        else
+          expect(network_resolver).to receive(:getnames).with(unresolved_ip).and_return(resolved_names)
+        end
+      end
+
+      let(:unresolved_ip) { '127.0.0.1' }
+      let(:resolved_names) { %w(localhost) }
+
+      it { expect(resolver.names_for(unresolved_ip)).to eq resolved_names }
+    end
+
+    context 'when network resolver can resolve name' do
+      before :each do
+        expect(hosts_resolver).to receive(:getnames).with(unresolved_ip).and_return([])
+        if RUBY_VERSION >= '2.1'
+          expect(local_link_resolver).to receive(:getnames).with(unresolved_ip).and_return([])
+        end
+        expect(network_resolver).to receive(:getnames).with(unresolved_ip).and_return(resolved_names)
+      end
+
+      let(:unresolved_ip) { '127.0.0.1' }
+      let(:resolved_names) { %w(localhost) }
+
+      it { expect(resolver.names_for(unresolved_ip)).to eq resolved_names }
+    end
+  end
+
+  describe '#ips_for' do
+    context 'when hosts resolver can resolve name' do
+      before :each do
+        expect(hosts_resolver).to receive(:getaddresses).with(unresolved_ips).and_return(resolved_name)
+        if RUBY_VERSION >= '2.1'
+          expect(local_link_resolver).not_to receive(:getaddresses)
+        end
+        expect(network_resolver).not_to receive(:getaddresses)
+      end
+
+      let(:unresolved_ips) { '127.0.0.1' }
+      let(:resolved_name) { %w(localhost) }
+
+      it { expect(resolver.ips_for(unresolved_ips)).to eq resolved_name }
+    end
+
+    context 'when local link resolver can resolve name' do
+      before :each do
+        expect(hosts_resolver).to receive(:getaddresses).with(unresolved_ips).and_return([])
+        if RUBY_VERSION >= '2.1'
+          expect(local_link_resolver).to receive(:getaddresses).with(unresolved_ips).and_return(resolved_name)
+          expect(network_resolver).not_to receive(:getaddresses)
+        else
+          expect(network_resolver).to receive(:getaddresses).with(unresolved_ips).and_return(resolved_name)
+        end
+      end
+
+      let(:unresolved_ips) { '127.0.0.1' }
+      let(:resolved_name) { %w(localhost) }
+
+      it { expect(resolver.ips_for(unresolved_ips)).to eq resolved_name }
+    end
+
+    context 'when network resolver can resolve name' do
+      before :each do
+        expect(hosts_resolver).to receive(:getaddresses).with(unresolved_ips).and_return([])
+        if RUBY_VERSION >= '2.1'
+          expect(local_link_resolver).to receive(:getaddresses).with(unresolved_ips).and_return([])
+        end
+        expect(network_resolver).to receive(:getaddresses).with(unresolved_ips).and_return(resolved_name)
+      end
+
+      let(:unresolved_ips) { '127.0.0.1' }
+      let(:resolved_name) { %w(localhost) }
+
+      it { expect(resolver.ips_for(unresolved_ips)).to eq resolved_name }
+    end
+  end
+end

data/spec/middleman-core/preview_server/server_hostname_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'middleman-core/preview_server/server_hostname'
+
+RSpec.describe Middleman::PreviewServer::ServerHostname do
+  subject(:hostname) { described_class.new(string) }
+  let(:string) { 'www.example.com' }
+
+  describe '#to_s' do
+    context 'when hostname' do
+      it { expect(hostname.to_s).to eq string }
+    end
+
+    context 'when ipv4' do
+      let(:string) { '127.0.0.1' }
+      it { expect(hostname.to_s).to eq string }
+    end
+
+    context 'when ipv6' do
+      let(:string) { '2607:f700:8000:12e:b3d9:1cba:b52:aa1b' }
+      it { expect(hostname.to_s).to eq string }
+    end
+  end
+
+  describe '#to_browser' do
+    context 'when hostname' do
+      it { expect(hostname.to_browser).to eq string }
+    end
+
+    context 'when ipv4' do
+      let(:string) { '127.0.0.1' }
+      it { expect(hostname.to_browser).to eq string }
+    end
+
+    context 'when ipv6' do
+      let(:string) { '::1' }
+      it { expect(hostname.to_browser).to eq string }
+    end
+  end
+end