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

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

@@ -7,6 +7,8 @@ module Middleman
       # Manages the list of proxy configurations and manipulates the sitemap
       # to include new resources based on those configurations
       class Proxies < Extension
+        self.resource_list_manipulator_priority = 0
+
         # Expose `create_proxy` as `app.proxy`
         expose_to_application proxy: :create_proxy
 
@@ -83,11 +85,20 @@ module Middleman
       end
     end
 
+    class Resource
+      def proxy_to(path)
+        throw "Resource#proxy_to has been removed. Use ProxyResource class instead."
+      end
+    end
+
     class ProxyResource < ::Middleman::Sitemap::Resource
+      Contract String
+      attr_reader :target
+
       # Initialize resource with parent store and URL
       # @param [Middleman::Sitemap::Store] store
       # @param [String] path
-      # @param [String] source_file
+      # @param [String] target
       def initialize(store, path, target)
         super(store, path)
 
@@ -115,8 +126,12 @@ module Middleman
       end
 
       Contract IsA['Middleman::SourceFile']
-      def source_file
-        target_resource.source_file
+      def file_descriptor
+        target_resource.file_descriptor
+      end
+
+      def metadata
+        target_resource.metadata.deep_merge super
       end
 
       Contract Maybe[String]

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

@@ -7,6 +7,8 @@ module Middleman
       # Manages the list of proxy configurations and manipulates the sitemap
       # to include new resources based on those configurations
       class Redirects < Extension
+        self.resource_list_manipulator_priority = 0
+
         # Expose `create_redirect` to config as `redirect`
         expose_to_config redirect: :create_redirect
 

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

@@ -4,6 +4,8 @@ module Middleman
   module Sitemap
     module Extensions
       class RequestEndpoints < Extension
+        self.resource_list_manipulator_priority = 0
+
         # Expose `create_endpoint` to config as `endpoint`
         expose_to_config endpoint: :create_endpoint
 

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

@@ -24,7 +24,7 @@ module Middleman
       # The on-disk source file for this resource, if there is one
       # @return [String]
       Contract Maybe[IsA['Middleman::SourceFile']]
-      attr_reader :source_file
+      attr_reader :file_descriptor
 
       # The path to use when requesting this resource. Normally it's
       # the same as {#destination_path} but it can be overridden in subclasses.
@@ -41,21 +41,21 @@ module Middleman
       # Initialize resource with parent store and URL
       # @param [Middleman::Sitemap::Store] store
       # @param [String] path
-      # @param [String] source_file
+      # @param [String] source
       Contract IsA['Middleman::Sitemap::Store'], String, Maybe[Or[IsA['Middleman::SourceFile'], String]] => Any
-      def initialize(store, path, source_file=nil)
+      def initialize(store, path, source=nil)
         @store       = store
         @app         = @store.app
         @path        = path
 
-        if source_file && source_file.is_a?(String)
-          source_file = Pathname(source_file)
+        if source && source.is_a?(String)
+          source = Pathname(source)
         end
 
-        if source_file && source_file.is_a?(Pathname)
-          @source_file = ::Middleman::SourceFile.new(source_file.relative_path_from(@app.source_dir), source_file, @app.source_dir, Set.new([:source]))
+        if source && source.is_a?(Pathname)
+          @file_descriptor = ::Middleman::SourceFile.new(source.relative_path_from(@app.source_dir), source, @app.source_dir, Set.new([:source]))
         else
-          @source_file = source_file
+          @file_descriptor = source
         end
 
         @destination_path = @path
@@ -71,8 +71,15 @@ module Middleman
       # @return [Boolean]
       Contract Bool
       def template?
-        return false if source_file.nil?
-        !::Tilt[source_file[:full_path].to_s].nil?
+        return false if file_descriptor.nil?
+        !::Tilt[file_descriptor[:full_path].to_s].nil?
+      end
+
+      # Backwards compatible method for turning descriptor into a string.
+      # @return [String]
+      Contract String
+      def source_file
+        file_descriptor && file_descriptor[:full_path].to_s
       end
 
       # Merge in new metadata specific to this resource.
@@ -87,8 +94,8 @@ module Middleman
       end
 
       # Data about this resource, populated from frontmatter or extensions.
-      # @return [IndifferentHash]
-      Contract IsA['Middleman::Util::IndifferentHash']
+      # @return [Hash]
+      Contract RespondTo[:indifferent_access?]
       def data
         ::Middleman::Util.recursively_enhance(metadata[:page])
       end
@@ -119,9 +126,9 @@ module Middleman
       # @return [String]
       Contract Hash, Hash => String
       def render(opts={}, locs={})
-        return ::Middleman::FileRenderer.new(@app, source_file[:full_path].to_s).template_data_for_file unless template?
+        return ::Middleman::FileRenderer.new(@app, file_descriptor[:full_path].to_s).template_data_for_file unless template?
 
-        ::Middleman::Util.instrument 'render.resource', path: source_file[:full_path].to_s, destination_path: destination_path do
+        ::Middleman::Util.instrument 'render.resource', path: file_descriptor[:full_path].to_s, destination_path: destination_path do
           md   = metadata
           opts = md[:options].deep_merge(opts)
           locs = md[:locals].deep_merge(locs)
@@ -132,7 +139,7 @@ module Middleman
             opts[:layout] = false if %w(.js .json .css .txt).include?(ext)
           end
 
-          renderer = ::Middleman::TemplateRenderer.new(@app, source_file[:full_path].to_s)
+          renderer = ::Middleman::TemplateRenderer.new(@app, file_descriptor[:full_path].to_s)
           renderer.render(locs, opts)
         end
       end
@@ -155,7 +162,7 @@ module Middleman
       # @return [Boolean]
       Contract Bool
       def binary?
-        !source_file.nil? && ::Middleman::Util.binary?(source_file[:full_path].to_s)
+        !file_descriptor.nil? && ::Middleman::Util.binary?(file_descriptor[:full_path].to_s)
       end
 
       # Ignore a resource directly, without going through the whole
@@ -174,7 +181,7 @@ module Middleman
         # Ignore based on the source path (without template extensions)
         return true if @app.sitemap.ignored?(path)
         # This allows files to be ignored by their source file name (with template extensions)
-        if !self.is_a?(ProxyResource) && source_file && @app.sitemap.ignored?(source_file[:relative_path].to_s)
+        if !self.is_a?(ProxyResource) && file_descriptor && @app.sitemap.ignored?(file_descriptor[:relative_path].to_s)
           true
         else
           false

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

@@ -188,6 +188,7 @@ module Middleman
           @app.logger.debug '== Rebuilding resource list'
 
           @resources = @resource_list_manipulators.reduce([]) do |result, m|
+            @app.logger.debug "== Running manipulator: #{m[:name]}"
             newres = m[:manipulator].send(m[:custom_name] || :manipulate_resource_list, result)
 
             # Reset lookup cache

data/lib/middleman-core/sources/source_watcher.rb

@@ -4,6 +4,26 @@ require 'middleman-core/contracts'
 require 'middleman-core/contracts'
 require 'backports/2.0.0/enumerable/lazy'
 
+# Monkey patch Listen silencer so `only` works on directories too
+module Listen
+  class Silencer
+    # TODO: switch type and path places - and verify
+    def silenced?(relative_path, type)
+      path = relative_path.to_s
+
+      # if only_patterns && type == :file
+      #   return true unless only_patterns.any? { |pattern| path =~ pattern }
+      # end
+
+      if only_patterns
+        return !only_patterns.any? { |pattern| path =~ pattern }
+      end
+
+      ignore_patterns.any? { |pattern| path =~ pattern }
+    end
+  end
+end
+
 module Middleman
   # The default source watcher implementation. Watches a directory on disk
   # and responds to events on changes.
@@ -29,6 +49,9 @@ module Middleman
     Contract Hash
     attr_reader :options
 
+    # Reference to lower level listener
+    attr_reader :listener
+
     # Construct a new SourceWatcher
     #
     # @param [Middleman::Sources] parent The parent collection.
@@ -138,9 +161,11 @@ module Middleman
       config[:latency] = @latency if @latency
 
       @listener = ::Listen.to(@directory.to_s, config, &method(:on_listener_change))
-      @listener.start
 
+      @listener.ignore(/^\.sass-cache/)
       @listener.only(@only) unless @only.empty?
+
+      @listener.start
     end
 
     # Stop the listener.

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(expand_path("."), "config-#{config_name}.rb")
+  config_dest = File.join(expand_path("."), '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(expand_path(".")) == 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, expand_path("."))
 
   step %Q{I cd to "#{path}"}
 end
@@ -58,20 +58,20 @@ 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(expand_path("."), 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(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|
-  check_file_content(file, Regexp.new(Regexp.escape(partial_content)), true)
+  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(current_dir, 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/middleman_steps.rb

@@ -1,9 +1,15 @@
 Then /^the file "([^\"]*)" has the contents$/ do |path, contents|
   write_file(path, contents)
-  @server_inst.files.find_new_files!
+
+  cd(".") do
+    @server_inst.files.find_new_files!
+  end
 end
 
 Then /^the file "([^\"]*)" is removed$/ do |path|
   step %Q{I remove the file "#{path}"}
-  @server_inst.files.find_new_files!
+
+  cd(".") do
+    @server_inst.files.find_new_files!
+  end
 end

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

@@ -31,8 +31,7 @@ Given /^"([^\"]*)" is set to "([^\"]*)"$/ do |variable, 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,7 +43,7 @@ Given /^the Server is running$/ do
 
   initialize_commands = @initialize_commands || []
 
-  in_current_dir do
+  cd(".") do
     @server_inst = ::Middleman::Application.new do
       config[:watcher_disable] = true
       config[:show_exceptions] = false
@@ -53,10 +52,10 @@ Given /^the Server is running$/ do
         instance_exec(&p)
       end
     end
-  end
 
-  rack = ::Middleman::Rack.new(@server_inst)
-  @browser = ::Rack::MockRequest.new(rack.to_app)
+    rack = ::Middleman::Rack.new(@server_inst)
+    @browser = ::Rack::MockRequest.new(rack.to_app)
+  end
 end
 
 Given /^the Server is running at "([^\"]*)"$/ do |app_path|
@@ -69,13 +68,13 @@ Given /^a template named "([^\"]*)" with:$/ do |name, string|
 end
 
 When /^I go to "([^\"]*)"$/ do |url|
-  in_current_dir do
+  cd(".") do
     @last_response = @browser.get(URI.encode(url))
   end
 end
 
 Then /^going to "([^\"]*)" should not raise an exception$/ do |url|
-  in_current_dir do
+  cd(".") do
     last_response = nil
     expect {
       last_response = @browser.get(URI.encode(url))
@@ -85,61 +84,61 @@ Then /^going to "([^\"]*)" should not raise an exception$/ do |url|
 end
 
 Then /^the content type should be "([^\"]*)"$/ do |expected|
-  in_current_dir do
+  cd(".") do
     expect(@last_response.content_type).to start_with(expected)
   end
 end
 
 Then /^I should see "([^\"]*)"$/ do |expected|
-  in_current_dir do
+  cd(".") do
     expect(@last_response.body).to include(expected)
   end
 end
 
 Then /^I should see '([^\']*)'$/ do |expected|
-  in_current_dir do
+  cd(".") do
     expect(@last_response.body).to include(expected)
   end
 end
 
 Then /^I should see:$/ do |expected|
-  in_current_dir do
+  cd(".") do
     expect(@last_response.body).to include(expected)
   end
 end
 
 Then /^I should not see "([^\"]*)"$/ do |expected|
-  in_current_dir do
+  cd(".") do
     expect(@last_response.body).to_not include(expected)
   end
 end
 
 Then /^I should see content matching %r{(.*)}$/ do |expected|
-  in_current_dir do
+  cd(".") do
     expect(@last_response.body).to match(expected)
   end
 end
 
 Then /^I should not see content matching %r{(.*)}$/ do |expected|
-  in_current_dir do
+  cd(".") do
     expect(@last_response.body).to_not match(expected)
   end
 end
 
 Then /^I should not see:$/ do |expected|
-  in_current_dir do
+  cd(".") do
     expect(@browser.last_response.body).to_not include(expected.chomp)
   end
 end
 
 Then /^the status code should be "([^\"]*)"$/ do |expected|
-  in_current_dir do
+  cd(".") do
     expect(@browser.last_response.status).to eq expected.to_i
   end
 end
 
 Then /^I should see "([^\"]*)" lines$/ do |lines|
-  in_current_dir do
+  cd(".") do
     expect(@last_response.body.chomp.split($/).length).to eq(lines.to_i)
   end
 end

data/lib/middleman-core/step_definitions.rb

@@ -1,5 +1,4 @@
 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'

data/lib/middleman-core/template_context.rb

@@ -128,7 +128,7 @@ module Middleman
       return unless resource = sitemap.find_resource_by_destination_path(current_path)
 
       # Look for partials relative to the current path
-      current_dir = resource.source_file[:relative_path].dirname
+      current_dir = resource.file_descriptor[:relative_path].dirname
       non_root = partial_path.to_s.sub(/^\//, '')
       relative_dir = current_dir + Pathname(non_root)
 
@@ -138,7 +138,7 @@ module Middleman
       partial_file = nil
 
       [
-        [relative_dir.to_s, { preferred_engine: resource.source_file[:relative_path].extname[1..-1].to_sym }],
+        [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 }],

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

@@ -0,0 +1,153 @@
+# Core Pathname library used for traversal
+require 'pathname'
+
+# DbC
+require 'middleman-core/contracts'
+
+# Shared util methods
+require 'middleman-core/util'
+
+# 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
+
+        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
+
+        return [{}, additional_content] if yaml_string.nil?
+
+        begin
+          data = map_value(::YAML.load(yaml_string) || {})
+        rescue *YAML_ERRORS => e
+          $stderr.puts "YAML Exception parsing #{full_path}: #{e.message}"
+          return nil
+        end
+
+        [data, additional_content]
+      rescue
+        [{}, additional_content]
+      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
+
+        [data, nil]
+      rescue
+        [{}, nil]
+      end
+
+      def symbolize_recursive(hash)
+        {}.tap do |h|
+          hash.each { |key, value| h[key.to_sym] = map_value(value) }
+        end
+      end
+
+      def map_value(thing)
+        case thing
+        when Hash
+          symbolize_recursive(thing)
+        when Array
+          thing.map { |v| map_value(v) }
+        else
+          thing
+        end
+      end
+    end
+  end
+end

data/lib/middleman-core/util.rb

@@ -11,8 +11,8 @@ require 'rack/mime'
 # DbC
 require 'middleman-core/contracts'
 
-# Immutable Data
-require 'hamster'
+# Indifferent Access
+require 'hashie'
 
 # For URI templating
 require 'addressable/uri'
@@ -76,56 +76,25 @@ module Middleman
       end
     end
 
-    class IndifferentHash < ::Hamster::Hash
-      def [](key)
-        if key?(key.to_sym)
-          super(key.to_sym)
-        elsif key?(key.to_s)
-          super(key.to_s)
-        else
-          super
-        end
-      end
-
-      def method_missing(key, *_args)
-        if key?(key.to_sym)
-          self[key.to_sym]
-        elsif key?(key.to_s)
-          self[key.to_s]
-        end
-      end
+    class EnhancedHash < ::Hashie::Mash
+      # include ::Hashie::Extensions::MergeInitializer
+      # include ::Hashie::Extensions::MethodReader
+      # include ::Hashie::Extensions::IndifferentAccess
     end
 
-    # Recursively convert a normal Hash into a IndifferentHash
+    # Recursively convert a normal Hash into a EnhancedHash
     #
     # @private
     # @param [Hash] data Normal hash
-    # @return [Middleman::Util::IndifferentHash]
-    FrozenDataStructure = Frozen[Or[IndifferentHash, Array, String, TrueClass, FalseClass, Fixnum, NilClass]]
-    Contract Maybe[Or[String, Array, Hash, IndifferentHash]] => Maybe[FrozenDataStructure]
+    # @return [Hash]
+    Contract Maybe[Hash] => Maybe[Or[Array, EnhancedHash]]
     def recursively_enhance(obj)
-      case obj
-      when ::Hash
-        res = obj.map { |key, value| [recursively_enhance(key), recursively_enhance(value)] }
-        IndifferentHash.new(res)
-      when IndifferentHash
-        obj.map { |key, value| [recursively_enhance(key), recursively_enhance(value)] }
-      when ::Array
-        res = obj.map { |element| recursively_enhance(element) }
-        Hamster::Vector.new(res)
-      when ::SortedSet
-        # This clause must go before ::Set clause, since ::SortedSet is a ::Set.
-        res = obj.map { |element| recursively_enhance(element) }
-        Hamster::SortedSet.new(res)
-      when ::Set
-        res = obj.map { |element| recursively_enhance(element) }
-        Hamster::Set.new(res)
-      when Hamster::Vector, Hamster::Set, Hamster::SortedSet
-        obj.map { |element| recursively_enhance(element) }
-      when ::TrueClass, ::FalseClass, ::Fixnum, ::Symbol, ::NilClass
-        obj
+      if obj.is_a? ::Array
+        obj.map { |e| recursively_enhance(e) }
+      elsif obj.is_a? ::Hash
+        ::Hashie::Mash.new(obj)
       else
-        obj.dup.freeze
+        obj
       end
     end
 

data/lib/middleman-core/version.rb

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