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

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

@@ -1,3 +1,5 @@
+require 'set'
+
 module Middleman
   module Util
     include Contracts
@@ -54,8 +56,10 @@ module Middleman
 
     Contract String => String
     def step_through_extensions(path)
-      while ::Tilt[path]
+      while ::Middleman::Util.tilt_class(path)
         ext = ::File.extname(path)
+        break if ext.empty?
+
         yield ext if block_given?
 
         # Strip templating extensions as long as Tilt knows them
@@ -80,13 +84,18 @@ module Middleman
     # @return [String]
     Contract String => ArrayOf[String]
     def collect_extensions(path)
-      return [] if ::File.basename(path).start_with?('.')
+      @@extensions_cache ||= {}
 
-      result = []
+      base_name = ::File.basename(path)
+      @@extensions_cache[base_name] ||= begin
+        result = []
 
-      step_through_extensions(path) { |e| result << e }
+        unless base_name.start_with?('.')
+          step_through_extensions(base_name) { |e| result << e }
+        end
 
-      result
+        result
+      end
     end
 
     # Finds files which should also be considered to be dirty when
@@ -99,35 +108,29 @@ module Middleman
     def find_related_files(app, files)
       return [] if files.empty?
 
-      all_extensions = files.flat_map { |f| collect_extensions(f.to_s) }
+      file_set = ::Set.new(files)
 
+      all_extensions = files.flat_map { |f| collect_extensions(f.to_s) }
       sass_type_aliasing = ['.scss', '.sass']
       erb_type_aliasing = ['.erb', '.haml', '.slim']
 
-      if (all_extensions & sass_type_aliasing).length > 0
-        all_extensions |= sass_type_aliasing
-      end
-
-      if (all_extensions & erb_type_aliasing).length > 0
-        all_extensions |= erb_type_aliasing
-      end
+      all_extensions |= sass_type_aliasing unless (all_extensions & sass_type_aliasing).empty?
+      all_extensions |= erb_type_aliasing unless (all_extensions & erb_type_aliasing).empty?
 
       all_extensions.uniq!
 
-      app.sitemap.resources.select(&:file_descriptor).select { |r|
-        local_extensions = collect_extensions(r.file_descriptor[:full_path].to_s)
+      app.sitemap.resources.select { |r|
+        if r.file_descriptor
+          local_extensions = collect_extensions(r.file_descriptor[:full_path].to_s)
+          local_extensions |= sass_type_aliasing unless (local_extensions & sass_type_aliasing).empty?
+          local_extensions |= erb_type_aliasing unless (local_extensions & erb_type_aliasing).empty?
 
-        if (local_extensions & sass_type_aliasing).length > 0
-          local_extensions |= sass_type_aliasing
-        end
+          local_extensions.uniq!
 
-        if (local_extensions & erb_type_aliasing).length > 0
-          local_extensions |= erb_type_aliasing
+          !(all_extensions & local_extensions).empty? && !file_set.include?(r.file_descriptor[:full_path])
+        else
+          false
         end
-
-        local_extensions.uniq!
-
-        ((all_extensions & local_extensions).length > 0) && files.none? { |f| f == r.file_descriptor[:full_path] }
       }.map(&:file_descriptor)
     end
   end

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

@@ -1,24 +1,41 @@
 # Core Pathname library used for traversal
 require 'pathname'
 require 'uri'
+require 'addressable'
+require 'memoist'
+require 'tilt'
 
 require 'middleman-core/contracts'
 
 # rubocop:disable ModuleLength
 module Middleman
   module Util
+    extend Memoist
     include Contracts
 
     module_function
 
+    Contract String => ::Addressable::URI
+    def parse_uri(uri)
+      ::Addressable::URI.parse(uri)
+    end
+    memoize :parse_uri
+
+    Contract String => Any
+    def tilt_class(path)
+      ::Tilt[path]
+    end
+    memoize :tilt_class
+
     # Normalize a path to not include a leading slash
     # @param [String] path
     # @return [String]
     Contract String => String
     def normalize_path(path)
-      # The tr call works around a bug in Ruby's Unicode handling
+     # The tr call works around a bug in Ruby's Unicode handling
       ::URI.decode(path).sub(%r{^/}, '').tr('', '')
-    end
+     end
+    memoize :normalize_path
 
     # This is a separate method from normalize_path in case we
     # change how we normalize paths
@@ -26,6 +43,26 @@ module Middleman
     def strip_leading_slash(path)
       path.sub(%r{^/}, '')
     end
+    memoize :strip_leading_slash
+
+    IGNORE_DESCRIPTOR = Or[Regexp, RespondTo[:call], String]
+    Contract IGNORE_DESCRIPTOR, String => Bool
+    def should_ignore?(validator, value)
+      if validator.is_a? Regexp
+        # Treat as Regexp
+        !!(value =~ validator)
+      elsif validator.respond_to? :call
+        # Treat as proc
+        validator.call(value)
+      elsif validator.is_a? String
+        # Treat as glob
+        File.fnmatch(value, validator)
+      else
+        # If some unknown thing, don't ignore
+        false
+      end
+    end
+    memoize :should_ignore?
 
     # Get the path of a file of a given type
     #
@@ -74,10 +111,16 @@ module Middleman
         raise ArgumentError, '#asset_url must be run in a context with current_resource if relative: true'
       end
 
-      uri = URI(path)
+      uri = ::Middleman::Util.parse_uri(path)
       path = uri.path
 
-      result = if resource = app.sitemap.find_resource_by_destination_path(url_for(app, path, options))
+      # Ensure the url we pass into find_resource_by_destination_path is not a
+      # relative path, since it only takes absolute url paths.
+      dest_path = url_for(app, path, options.merge(relative: false))
+
+      result = if resource = app.sitemap.find_resource_by_path(dest_path)
+        resource.url
+      elsif resource = app.sitemap.find_resource_by_destination_path(dest_path)
         resource.url
       else
         path = ::File.join(prefix, path)
@@ -88,9 +131,15 @@ module Middleman
         end
       end
 
-      final_result = ::URI.encode(relative_path_from_resource(options[:current_resource], result, options[:relative]))
+      final_result = ::Addressable::URI.encode(
+        relative_path_from_resource(
+          options[:current_resource],
+          result,
+          options[:relative]
+        )
+      )
 
-      result_uri = URI(final_result)
+      result_uri = ::Middleman::Util.parse_uri(final_result)
       result_uri.query = uri.query
       result_uri.fragment = uri.fragment
       result_uri.to_s
@@ -99,8 +148,13 @@ module Middleman
     # Given a source path (referenced either absolutely or relatively)
     # or a Resource, this will produce the nice URL configured for that
     # path, respecting :relative_links, directory indexes, etc.
-    Contract ::Middleman::Application, Or[String, ::Middleman::Sitemap::Resource], Hash => String
+    Contract ::Middleman::Application, Or[String, Symbol, ::Middleman::Sitemap::Resource], Hash => String
     def url_for(app, path_or_resource, options={})
+      if path_or_resource.is_a?(String) || path_or_resource.is_a?(Symbol)
+        r = app.sitemap.find_resource_by_page_id(path_or_resource)
+        path_or_resource = r if r
+      end
+
       # Handle Resources and other things which define their own url method
       url = if path_or_resource.respond_to?(:url)
         path_or_resource.url
@@ -110,8 +164,8 @@ module Middleman
 
       # Try to parse URL
       begin
-        uri = URI(url)
-      rescue ::URI::InvalidURIError
+        uri = ::Middleman::Util.parse_uri(url)
+      rescue ::Addressable::URI::InvalidURIError
         # Nothing we can do with it, it's not really a URI
         return url
       end
@@ -154,7 +208,13 @@ module Middleman
 
       if resource
         uri.path = if this_resource
-          ::URI.encode(relative_path_from_resource(this_resource, resource_url, effective_relative))
+          ::Addressable::URI.encode(
+            relative_path_from_resource(
+              this_resource,
+              resource_url,
+              effective_relative
+            )
+          )
         else
           resource_url
         end
@@ -232,20 +292,20 @@ module Middleman
     # @return [Boolean] Whether the path matches the matcher
     Contract PATH_MATCHER, String => Bool
     def path_match(matcher, path)
-      case
-      when matcher.is_a?(String)
+      if matcher.is_a?(String)
         if matcher.include? '*'
           ::File.fnmatch(matcher, path)
         else
           path == matcher
         end
-      when matcher.respond_to?(:match)
+      elsif matcher.respond_to?(:match)
         !!(path =~ matcher)
-      when matcher.respond_to?(:call)
+      elsif matcher.respond_to?(:call)
         matcher.call(path)
       else
         ::File.fnmatch(matcher.to_s, path)
       end
     end
+    memoize :path_match
   end
 end

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

@@ -20,9 +20,9 @@ module Middleman
       result
     end
 
-    Contract String, String, ArrayOf[String], Proc => String
-    def rewrite_paths(body, _path, exts, &_block)
-      matcher = /([\'\"\(,]\s*)([^\s\'\"\)>]+(#{::Regexp.union(exts)}))/
+    Contract String, String, ArrayOf[String], IsA['::Middleman::Application'], Proc => String
+    def rewrite_paths(body, path, exts, app, &_block)
+      matcher = /([\'\"\(,]\s*|# sourceMappingURL=)([^\s\'\"\)\(>]+(#{::Regexp.union(exts)}))/
 
       url_fn_prefix = 'url('
 
@@ -35,11 +35,21 @@ module Middleman
           asset_path = asset_path[url_fn_prefix.length..-1]
         end
 
+        current_resource = app.sitemap.find_resource_by_destination_path(path)
+
         begin
-          uri = ::Addressable::URI.parse(asset_path)
+          uri = ::Middleman::Util.parse_uri(asset_path)
+
+          if uri.relative? && uri.host.nil? && !(asset_path =~ /^[^\/].*[a-z]+\.[a-z]+\/.*/)
+            dest_path = ::Middleman::Util.url_for(app, asset_path, relative: false, current_resource: current_resource)
+
+            resource = app.sitemap.find_resource_by_destination_path(dest_path)
 
-          if uri.relative? && uri.host.nil? && !(asset_path =~ /^[^\/].*[a-z]+\.[a-z]+\/.*/) && (result = yield(asset_path))
-            "#{opening_character}#{result}"
+            if resource && (result = yield(asset_path))
+              "#{opening_character}#{result}"
+            else
+              match
+            end
           else
             match
           end

data/lib/middleman-core/version.rb

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

data/middleman-core.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |s|
   s.email       = ['me@tdreyno.com', 'ben@benhollis.net', 'karlfreeman@gmail.com']
   s.homepage    = 'http://middlemanapp.com'
   s.summary     = 'Hand-crafted frontend development'
-  s.description = 'Patch containing: https://github.com/middleman/middleman/pull/2190. A static site generator. Provides dozens of templating languages (Haml, Sass, Compass, Slim, CoffeeScript, and more). Makes minification, compression, cache busting, Yaml data (and more) an easy part of your development cycle.'
+  s.description = 'Contains patch https://github.com/middleman/middleman/pull/2190. A static site generator. Provides dozens of templating languages (Haml, Sass, Compass, Slim, CoffeeScript, and more). Makes minification, compression, cache busting, Yaml data (and more) an easy part of your development cycle.'
 
   s.files        = `git ls-files -z`.split("\0")
   s.test_files   = `git ls-files -z -- {fixtures,features}/*`.split("\0")
@@ -25,36 +25,39 @@ Gem::Specification.new do |s|
   s.add_dependency('erubis')
   s.add_dependency('fast_blank')
   s.add_dependency('parallel')
+  s.add_dependency('servolux')
+  s.add_dependency('dotenv')
 
   # Helpers
   s.add_dependency('activesupport', ['~> 4.2'])
   s.add_dependency('padrino-helpers', ['~> 0.13.0'])
-  s.add_dependency("addressable", ["~> 2.4.0"])
+  s.add_dependency("addressable", ["~> 2.3"])
+  s.add_dependency('memoist', ['~> 0.14'])
 
   # Watcher
-  s.add_dependency('listen', ['~> 3.0'])
+  s.add_dependency('listen', ['~> 3.0.0'])
 
   # Tests
-  s.add_dependency("capybara", ["~> 2.5.0"])
+  s.add_development_dependency("capybara", ["~> 2.5.0"])
 
   # i18n
   s.add_dependency('i18n', ['~> 0.7.0'])
 
   # Automatic Image Sizes
-  s.add_dependency('fastimage', ['~> 1.8'])
+  s.add_dependency('fastimage', ['~> 2.0'])
 
   # Minify CSS
   s.add_dependency('sass', ['>= 3.4'])
 
   # Minify JS
-  s.add_dependency('uglifier', ['~> 2.6'])
+  s.add_dependency('uglifier', ['~> 3.0'])
   s.add_dependency('execjs', ['~> 2.0'])
 
   # Testing
-  s.add_dependency('contracts', ['~> 0.12.0'])
+  s.add_dependency('contracts', ['~> 0.13.0'])
 
   # Hash stuff
   s.add_dependency('hashie', ['~> 3.4'])
-  s.add_dependency('hamster', ['~> 2.0'])
+  s.add_dependency('hamster', ['~> 3.0'])
   s.add_dependency('backports', ['~> 3.6'])
 end

data/spec/middleman-core/core_extensions/data_spec.rb

@@ -7,6 +7,112 @@ end
 
 describe Middleman::CoreExtensions::Data::DataStore do
 
+  describe "#store" do
+    before :each do
+      @subject = described_class.new instance_double("Middleman::Application"),
+                                     Middleman::CoreExtensions::Data::DATA_FILE_MATCHER
+    end
+
+    context "when given a name and data" do
+      it "adds data at the given name" do
+        @subject.store :foo, { 'bar' => 'baz' }
+        @subject.store :baz, [:wu, :tang]
+
+        expect( @subject.store['foo'] ).to eq({ 'bar' => 'baz' })
+        expect( @subject.store['baz'] ).to match_array [:wu, :tang]
+      end
+
+      it "overwrites previous keys if given the same key" do
+        @subject.store :foo, { 'bar' => 'baz' }
+        @subject.store :foo, [:wu, :tang]
+
+        expect( @subject.store['foo'] ).to match_array [:wu, :tang]
+      end
+    end
+
+    context "when given no args" do
+      it "returns @local_sources instance var" do
+        @subject.instance_variable_set :"@local_sources", { foo: 'bar' }
+        expect( @subject.store ).to eq({ foo: 'bar' })
+      end
+    end
+  end
+
+  describe "#callbacks" do
+    before :each do
+      @subject = described_class.new instance_double("Middleman::Application"),
+                                     Middleman::CoreExtensions::Data::DATA_FILE_MATCHER
+    end
+
+    context "when given a name and proc" do
+      it "adds a callback at the given name" do
+        @subject.callbacks :foo, lambda { "bar" }
+        callback = @subject.instance_variable_get(:@callback_sources)['foo']
+
+        expect( callback.call ).to eq "bar"
+      end
+
+      it "overwrites previous keys if given the same key" do
+        @subject.callbacks :foo, lambda { "bar" }
+        @subject.callbacks :foo, lambda { "baz" }
+        callback = @subject.instance_variable_get(:@callback_sources)['foo']
+
+        expect( callback.call ).to eq "baz"
+      end
+    end
+
+    context "when given no args" do
+      it "returns @callback_sources instance var" do
+        @subject.instance_variable_set :"@callback_sources", { foo: 'bar' }
+        expect( @subject.callbacks ).to eq({ foo: 'bar' })
+      end
+    end
+  end
+
+  describe "#data_for_path" do
+    before :each do
+      @subject = described_class.new instance_double("Middleman::Application"),
+                                     Middleman::CoreExtensions::Data::DATA_FILE_MATCHER
+    end
+
+    context "given path matches local data" do
+      it "returns hash for key" do
+        @subject.store :foo, { 'bar' => 'baz' }
+        expect( @subject.data_for_path(:foo) ).to eq({ 'bar' => 'baz' })
+      end
+
+      it "returns array for key" do
+        @subject.store :foo, [:bar, :baz]
+        expect( @subject.data_for_path(:foo) ).to match_array [:bar, :baz]
+      end
+    end
+
+    context "given path matches callback data" do
+      it "returns value of calback lambda" do
+        @subject.callbacks :foo, lambda { { 'bar' => 'baz' } }
+        @subject.callbacks :wu, lambda { [:tang, :clan] }
+
+        expect( @subject.data_for_path(:foo) ).to eq({ 'bar' => 'baz' })
+        expect( @subject.data_for_path(:wu) ).to match_array [:tang, :clan]
+      end
+    end
+
+    context "given path matches both sources" do
+      it "returns match from local data" do
+        @subject.store :foo, { 'local' => 'data' }
+        @subject.callbacks :foo, lambda { { 'callback' => 'data' } }
+
+        expect( @subject.data_for_path(:foo) ).to eq({ 'local' => 'data' })
+      end
+    end
+
+    context "given path matches no sources" do
+      it "returns nil" do
+        expect( @subject.data_for_path(:missing) ).to be_nil
+      end
+    end
+  end
+
   describe "#key?" do
 
     it "returns true if key included in local_data, local_sources, or callback_sources" do
@@ -38,4 +144,4 @@ describe Middleman::CoreExtensions::Data::DataStore do
 
   end
 
-end
+end