middleman-sprockets 3.3.10 → 3.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b6a53ba2d0dd29b13117f9b2135d06380eff8f9
-  data.tar.gz: 1f769aa917cc361929f40e6d1043939c53e42da4
+  metadata.gz: 10c8f9ee3155e55fa3f141e5396cfac8ca05e3a5
+  data.tar.gz: 7ef430536757c24bf59da6aeb2563725415e0db1
 SHA512:
-  metadata.gz: 3da8a43ce7f08325062ee16004fc21bd1f5bf9f3e15e25342b14e590abf3d6a33dce87a9e7fc22cd67371598d09cd722e6376127138c9918333f2c1b2d13005e
-  data.tar.gz: 7c485931a8d82e1a60f188ac9c731418c347aef108beba1df366575fb05e90e8628f2f515e3d7e8d03b0411ff5da7ff6cb3151db84fe4be50dba3eb4a3812857
+  metadata.gz: ed05bb9f91b5272b6540eccf96ee5722bb54e8b9972988db0e54f9d15bebaf827fc58b181760af011ff1c9a898f786294c328be949cb7e2b76869751073575d6
+  data.tar.gz: 49d1cc180c9ca4127859bc9564749aaffa93c26e925bac02b7df58fe169ba3a54c0a07a823846304731be5db22c973cd2656f2bdcde3a5956c50466625e4520d

data/Gemfile

@@ -12,7 +12,7 @@ gem "yard", "~> 0.8.0", :require => false
 gem "cucumber"
 gem "fivemat", "~> 1.2.1"
 gem "aruba"
-gem "rspec"
+gem "rspec", "~> 3.0"
 gem "builder", "~> 3.0"
 gem "simplecov"
 

data/Rakefile

@@ -13,7 +13,11 @@ Cucumber::Rake::Task.new(:cucumber, 'Run features that should pass') do |t|
   t.cucumber_opts = "--color #{exempt_tags.join(" ")} --strict --format #{ENV['CUCUMBER_FORMAT'] || 'Fivemat'}"
 end
 
-RSpec::Core::RakeTask.new(:spec)
+RSpec::Core::RakeTask.new(:spec) do |t|
+  if RUBY_VERSION < '2.0'
+    t.rspec_opts = '--tag ~@skip:one-nine'
+  end
+end
 
 require 'rake/clean'
 

data/features/sprockets.feature

@@ -146,3 +146,15 @@ Feature: Sprockets
     Then a file named "fonts/font-awesome/fonts/fontawesome-webfont-bower.svg.gz" should exist
     Then a file named "javascripts/jquery/jquery.min.js" should exist
     Then a file named "javascripts/jquery/jquery.asdf.asdf.js.min.asdf" should exist
+
+  Scenario: Imported Asset matches multiple sprockets paths
+    Given a successfully built app at "sprockets-imported-assets-match-multiple-paths-app"
+    When I cd to "build"
+    Then a file named "assets/css/test.css" should exist
+    And a file named "assets/css/css/test.css" should not exist
+
+  Scenario: Imported Asset has a different 'asset type' directory than in config
+    Given a successfully built app at "sprockets-imported-asset-path-conflicts-app"
+    When I cd to "build"
+    Then a file named "assets/css/test.css" should exist
+    And a file named "assets/css/stylesheets/test.css" should not exist

data/fixtures/sprockets-imported-asset-path-conflicts-app/config.rb

@@ -0,0 +1,4 @@
+set :css_dir, "assets/css"
+
+sprockets.append_path File.join(root, 'resources/assets')
+sprockets.import_asset "stylesheets/test"

data/fixtures/sprockets-imported-asset-path-conflicts-app/resources/assets/stylesheets/test.css

@@ -0,0 +1,3 @@
+body {
+  background: #fd0;
+}

data/fixtures/sprockets-imported-assets-match-multiple-paths-app/config.rb

@@ -0,0 +1,4 @@
+set :css_dir, "assets/css"
+
+sprockets.append_path File.join(root, 'vendor/assets')
+sprockets.import_asset "css/test"

data/fixtures/sprockets-imported-assets-match-multiple-paths-app/vendor/assets/css/test.css

@@ -0,0 +1,3 @@
+body {
+  background: #fd0;
+}

data/lib/middleman-sprockets.rb

@@ -1,6 +1,11 @@
 require "middleman-core"
 
-Middleman::Extensions.register(:sprockets) do
+params = [:sprockets]
+
+# If we're in v4
+params << { auto_activate: :before_configuration } if Middleman::Extensions.method(:register).arity != -1
+
+Middleman::Extensions.register(*params) do
   require "middleman-sprockets/extension"
   Middleman::SprocketsExtension
-end
+end

data/lib/middleman-sprockets/asset.rb

@@ -1,99 +1,40 @@
 # encoding: utf-8
 module Middleman
   module Sprockets
-    # Asset 
-    class Asset
-      attr_reader :source_path, :relative_source_path, :base_name, :destination_directory, :source_directory
-
-      # Create instance
-      #
-      # @param [Pathname] logical_path
-      #   The logical path to the asset given in config.rb
-      #
-      # @param [proc] output_dir
-      #   An individual output directory for that particular asset
-      def initialize(source_path, options)
-        source_directory = options.fetch(:source_directory, nil)
-
-        fail ArgumentError, 'Missing argument source_directory' unless source_directory
-
-        @source_directory = source_directory
-
-        @source_path = Pathname.new(source_path)
-        @relative_source_path = @source_path.relative_path_from(Pathname.new(source_directory))
-        @base_name = @source_path.basename
-        @import_it = false
-      end
-
-      # Should the asset imported?
-      #
-      # @return [true, false]
-      #   Is true if it should be imported
-      def import?
-        valid? && (in_trusted_source_directory? || import_it?)
-      end
-
-      # Check on file type
-      #
-      # @return [true, false]
-      #   Is true if has type
-      def has_type?(t)
-        type == t
-      end
-
-      # Path where the asset should be stored
-      #
-      # @return [Pathname]
-      #    Returns `destination_path` if set, otherwise build result: destination_directory + relative_source_path
-      #
-      # @raise [::Sprockets::FileNotFound]
-      #   Raise error if destination_directory was not set previously from outside
-      def destination_path
-        return @destination_path if @destination_path
 
-        fail ::Sprockets::FileNotFound, "Couldn't find an appropriate output directory for '#{source_path}'. Halting because it was explicitly requested via 'import_asset'" unless destination_directory
+    class Asset
 
-        destination_directory + relative_source_path
-      end
+      attr_reader :app, :sprockets, :asset
 
-      # Sets the destination_path
-      #
-      # @param [String,Pathname] path
-      #   The output path for asset as string or pathname. It will be converted
-      #   to `Pathname`.
-      def destination_path=(path)
-        @destination_path = Pathname.new path
-      end
+      def initialize app, lookup_path, sprockets = app.sprockets
+        @app       = app
+        @sprockets = sprockets
+        @asset     = sprockets[ sprockets.resolve(lookup_path) ]
 
-      # Set destination directory
-      #  
-      #  @param [String] path
-      #    The path to the destination directory
-      #
-      #  @return [Pathname]
-      #    The path as pathname
-      def destination_directory=(path)
-        @destination_directory = Pathname.new path
+        raise ::Sprockets::FileNotFound, "Couldn't find asset '#{lookup_path}'" if @asset.nil?
       end
 
-      # Check if given path matches source_path
-      #
-      # @param [String] path
-      #   The path to be checked
-      # @return [true, false]
-      #   The result of check
-      def match?(path)
-        source_path == Pathname.new(path)
+      def destination_path
+        case type
+        when :image then
+          Pathname.new(app.config[:images_dir]) + remove_asset_dir(asset.logical_path, image_paths)
+        when :script then
+          Pathname.new(app.config[:js_dir]) + remove_asset_dir(asset.logical_path, script_paths)
+        when :font then
+          Pathname.new(app.config[:fonts_dir]) + remove_asset_dir(asset.logical_path, font_paths)
+        when :stylesheet then
+          Pathname.new(app.config[:css_dir]) + remove_asset_dir(asset.logical_path, stylesheet_paths)
+        else
+          asset.logical_path
+        end
       end
 
-      # Tell asset that it is importable
-      def import_it
-        @import_it = true # single =
+      def source_dir
+        @source_dir ||= source_path.sub /\/?#{asset.logical_path}$/, ''
       end
 
-      def in_trusted_source_directory?
-        source_directory.end_with?('images') ||
-        source_directory.end_with?('fonts')
+      def source_path
+        asset.pathname
       end
 
       def type
@@ -110,31 +51,14 @@ module Middleman
                   end
       end
 
-      def file?
-        source_path.file?
-      end
-
-      def partial?
-        base_name.to_s.start_with? '_'
-      end
-
-      # Is it a valid asset
-      # @return [true, false]
-      #   If the asset is valid return true
-      def valid?
-        file? && !partial?
-      end
-
-      def import_it?
-        @import_it == true # double =
-      end
+      private
 
-      def has_extname?(*exts)
-        !(extname & exts).empty?
+      def has_extname? *exts
+        !(exts & asset.pathname.to_s.scan(/(\.[^.]+)/).flatten).empty?
       end
 
-      def extname
-        source_path.basename.to_s.scan(/(\.[^.]+)/).flatten
+      def remove_asset_dir pathname, asset_dir_paths
+        pathname.sub(/^(#{asset_dir_paths.map { |p| Regexp.new(p) }.join('|')})\/?/, '')
       end
 
       def is_image?
@@ -142,10 +66,8 @@ module Middleman
       end
 
       def is_image_by_path?
-        File.basename(source_directory.to_s) == 'images' ||
-        File.basename(source_directory.to_s) == 'img' ||
-        source_path.dirname.basename.to_s == 'images' ||
-        source_path.dirname.basename.to_s == 'img'
+        image_paths.include?(source_path.dirname.basename.to_s) ||
+        image_paths.include?(File.basename(source_dir.to_s))
       end
       alias_method :is_in_images_directory?, :is_image_by_path?
 
@@ -153,19 +75,26 @@ module Middleman
         has_extname?(*%w(.gif .png .jpg .jpeg .webp .svg .svgz))
       end
 
+      def image_paths
+        %w( images img )
+      end
+
       def is_stylesheet?
         is_stylesheet_by_path? || is_stylesheet_by_extension?
       end
 
+      def is_stylesheet_by_path?
+        stylesheet_paths.include?(source_path.dirname.basename.to_s) ||
+        stylesheet_paths.include?(File.basename(source_dir.to_s))
+      end
+      alias_method :is_in_stylesheet_directory?, :is_stylesheet_by_path?
+
       def is_stylesheet_by_extension?
         has_extname?(*%w(.css .sass .scss .styl .less))
       end
 
-      def is_stylesheet_by_path?
-        File.basename(source_directory.to_s) == 'stylesheets' ||
-        File.basename(source_directory.to_s) == 'css' ||
-        source_path.dirname.basename.to_s == 'stylesheets' ||
-        source_path.dirname.basename.to_s == 'css'
+      def stylesheet_paths
+        %w( stylesheets css )
       end
 
       def is_font?
@@ -173,8 +102,8 @@ module Middleman
       end
 
       def is_font_by_path?
-        File.basename(source_directory.to_s) == 'fonts' ||
-        source_path.dirname.basename.to_s == 'fonts'
+        font_paths.include?(source_path.dirname.basename.to_s) ||
+        font_paths.include?(File.basename(source_dir.to_s))
       end
       alias_method :is_in_fonts_directory?, :is_font_by_path?
 
@@ -182,20 +111,28 @@ module Middleman
         has_extname?(*%w(.ttf .woff .eot .otf .svg .svgz))
       end
 
+      def font_paths
+        %w( fonts )
+      end
+
       def is_script?
         is_script_by_path? || is_script_by_extension?
       end
 
       def is_script_by_path?
-        File.basename(source_directory.to_s) == 'javascripts' ||
-        File.basename(source_directory.to_s) == 'js' ||
-        source_path.dirname.basename.to_s == 'javascripts' ||
-        source_path.dirname.basename.to_s == 'js'
+        script_paths.include?(source_path.dirname.basename.to_s) ||
+        script_paths.include?(File.basename(source_dir.to_s))
       end
+      alias_method :is_in_scripts_directory?, :is_script_by_path?
 
       def is_script_by_extension?
         has_extname?(*%w(.js .coffee))
       end
+
+      def script_paths
+        %w( javascripts js )
+      end
+
     end
   end
 end

data/lib/middleman-sprockets/environment.rb

@@ -215,6 +215,14 @@ module Middleman
           return response
         end
 
+        if resource
+          # incase the path has been rewrite, let sprockets know the original so it can find it
+          logical_path = resource.metadata.fetch(:options, {})
+                                          .fetch(:sprockets, {})
+                                          .fetch(:logical_path, nil)
+          env['PATH_INFO'] = logical_path.to_s if logical_path
+        end
+
         super
       end
 

data/lib/middleman-sprockets/extension.rb

@@ -2,11 +2,22 @@ require "sprockets"
 require "sprockets-sass"
 require "middleman-sprockets/asset"
 require "middleman-sprockets/imported_asset"
-require "middleman-sprockets/asset_list"
 require "middleman-sprockets/config_only_environment"
 require "middleman-sprockets/environment"
 require "middleman-sprockets/asset_tag_helpers"
 
+class Sprockets::Sass::SassTemplate
+  # Get the default, global Sass options. Start with Compass's
+  # options, if it's available.
+  def default_sass_options
+    if defined?(Compass) && defined?(Compass.configuration)
+      merge_sass_options Compass.configuration.to_sass_engine_options.dup, Sprockets::Sass.options
+    else
+      Sprockets::Sass.options.dup
+    end
+  end
+end
+
 # Sprockets extension
 module Middleman
   class SprocketsExtension < Extension
@@ -26,13 +37,19 @@ module Middleman
 
     def initialize(app, options_hash={}, &block)
       require "middleman-sprockets/sass_function_hack"
+      require "middleman-sprockets/sass_utils"
 
       super
 
       # Start out with a stub environment that can only be configured (paths and such)
       @environment = ::Middleman::Sprockets::ConfigOnlyEnvironment.new
 
-      app.send :include, SprocketsAccessor
+      # v4
+      if app.respond_to? :add_to_config_context
+        app.add_to_config_context :sprockets, &method(:environment)
+      else
+        app.send :include, SprocketsAccessor
+      end
     end
 
     helpers do
@@ -45,7 +62,9 @@ module Middleman
       ::Tilt.register ::Sprockets::EcoTemplate, 'eco'
       ::Tilt.register ::Sprockets::JstProcessor, 'jst'
 
-      app.template_extensions :jst => :js, :eco => :js, :ejs => :js
+      if app.respond_to?(:template_extensions)
+        app.template_extensions :jst => :js, :eco => :js, :ejs => :js
+      end
 
       if app.config.defines_setting?(:debug_assets) && !options.setting(:debug_assets).value_set?
         options[:debug_assets] = app.config[:debug_assets]
@@ -57,6 +76,7 @@ module Middleman
       config_environment.apply_to_environment(@environment)
 
       append_paths_from_gems
+      import_images_and_fonts_from_gems
 
       # Setup Sprockets Sass options
       if app.config.defines_setting?(:sass)
@@ -73,43 +93,24 @@ module Middleman
 
     # Add sitemap resource for every image in the sprockets load path
     def manipulate_resource_list(resources)
-      imported_assets = Middleman::Sprockets::AssetList.new
-
-      environment.imported_assets.each do |asset|
-        asset.resolve_path_with environment
-        @app.logger.debug "== Importing Sprockets asset #{asset.real_path}"
-
-        imported_assets << asset
-      end
-
       resources_list = []
-      environment.paths.each do |load_path|
-        environment.each_entry(load_path) do |path|
-          asset = Middleman::Sprockets::Asset.new(path, source_directory: load_path)
-
-          imported_assets.lookup(asset) do |candidate, found_asset| 
-            candidate.destination_path = found_asset.output_path if found_asset.output_path
-            candidate.import_it
-          end
 
-          next unless asset.import?
+      environment.imported_assets.each do |imported_asset|
+        asset = Middleman::Sprockets::Asset.new @app, imported_asset.logical_path, environment
+        if imported_asset.output_path
+          destination = imported_asset.output_path
+        else
+          destination = @app.sitemap.extensionless_path( asset.destination_path.to_s )
+        end
 
-          if asset.has_type? :image
-            asset.destination_directory = @app.config[:images_dir]
-          elsif asset.has_type? :script
-            asset.destination_directory = @app.config[:js_dir]
-          elsif asset.has_type? :font
-            asset.destination_directory = @app.config[:fonts_dir]
-          elsif asset.has_type? :stylesheet
-            asset.destination_directory = @app.config[:css_dir]
-          end
+        next if @app.sitemap.find_resource_by_destination_path destination.to_s
 
-          new_path = @app.sitemap.extensionless_path(asset.destination_path.to_s)
+        resource = ::Middleman::Sitemap::Resource.new( @app.sitemap, destination.to_s, asset.source_path.to_s )
+        resource.add_metadata options: { sprockets: { logical_path: imported_asset.logical_path }}
 
-          next if @app.sitemap.find_resource_by_destination_path(new_path.to_s)
-          resources_list << ::Middleman::Sitemap::Resource.new(@app.sitemap, new_path.to_s, path.to_s)
-        end
+        resources_list << resource
       end
+
       resources + resources_list
     end
 
@@ -117,7 +118,7 @@ module Middleman
 
     # Add any directories from gems with Rails-like paths to sprockets load path
     def append_paths_from_gems
-      root_paths = ::Middleman.rubygems_latest_specs.map(&:full_gem_path) << app.root
+      root_paths = rubygems_latest_specs.map(&:full_gem_path) << app.root
       base_paths = %w[assets app app/assets vendor vendor/assets lib lib/assets]
       asset_dirs = %w[javascripts js stylesheets css images img fonts]
 
@@ -126,5 +127,31 @@ module Middleman
         environment.append_path(path) if File.directory?(path)
       end
     end
+
+    # Backwards compatible means of finding all the latest gemspecs
+    # available on the system
+    #
+    # @private
+    # @return [Array] Array of latest Gem::Specification
+    def rubygems_latest_specs
+      # If newer Rubygems
+      if ::Gem::Specification.respond_to? :latest_specs
+        ::Gem::Specification.latest_specs(true)
+      else
+        ::Gem.source_index.latest_specs
+      end
+    end
+
+    def import_images_and_fonts_from_gems
+      trusted_paths = environment.paths.select { |p| p.end_with?('images') || p.end_with?('fonts') }
+      trusted_paths.each do |load_path|
+        environment.each_entry(load_path) do |path|
+          if path.file? && !path.basename.to_s.start_with?('_')
+            logical_path = path.sub /^#{load_path}/, ''
+            environment.imported_assets << Middleman::Sprockets::ImportedAsset.new(logical_path)
+          end
+        end
+      end
+    end
   end
 end

data/lib/middleman-sprockets/imported_asset.rb

@@ -1,9 +1,9 @@
 # encoding: utf-8
 module Middleman
   module Sprockets
-    # ImportedAsset 
+    # ImportedAsset
     class ImportedAsset
-      attr_reader :logical_path, :output_path, :real_path
+      attr_reader :logical_path, :output_path
 
       # Create instance
       #
@@ -12,45 +12,18 @@ module Middleman
       #
       # @param [proc] output_dir
       #   An individual output directory for that particular asset
-      def initialize(logical_path, determine_output_path = proc { nil })
-        @logical_path = Pathname.new(logical_path)
-        @output_path  = if output_path = determine_output_path.call(@logical_path)
-                          Pathname.new(output_path)
-                        else
-                          nil
-                        end
-      end
-
-      # Resolve logical path to real path
-      # 
-      # @param [#resolve] resolver
-      #   The objects which is able to resolve a logical path
-      def resolve_path_with(resolver)
-        @real_path = resolver.resolve(logical_path)
-
-        raise ::Sprockets::FileNotFound, "Couldn't find asset '#{logical_path}'" if real_path == nil || real_path == ''
-      end
-
-      # String representation of asset
-      #
-      # @return [String]
-      #   The logical path as string
-      def to_s
-        logical_path.to_s
-      end
-
-      # Does the given patch matches asset
-      # 
-      # @param [Pathname] path
-      #   The path to be checked
-      def match?(path)
-        has_real_path? path
-      end
+      def initialize logical_path, output_path = nil
+        @logical_path = Pathname.new logical_path
 
-      private
+        if output_path.respond_to? :call
+          if output_path.arity.abs == 1
+            output_path = output_path.call(@logical_path)
+          else
+            output_path = output_path.call
+          end
+        end
 
-      def has_real_path?(path)
-        real_path == path
+        @output_path = Pathname.new output_path if output_path
       end
     end
   end

data/lib/middleman-sprockets/sass_utils.rb

@@ -0,0 +1,14 @@
+if defined?(Sass)
+
+  module Sass::Script::Functions
+
+    ##
+    # A reference to the Middleman::Application object.
+    #
+    def middleman_app
+      options[:custom][:sprockets_context].app
+    end
+
+  end
+
+end

data/lib/middleman-sprockets/version.rb

@@ -1,5 +1,5 @@
 module Middleman
   module Sprockets
-    VERSION = "3.3.10"
+    VERSION = "3.4.1"
   end
 end

data/middleman-sprockets.gemspec

@@ -15,8 +15,8 @@ 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_paths = ["lib"]
-  s.add_dependency("middleman-core", ["~> 3.3"])
+  s.add_dependency("middleman-core", [">= 3.3"])
   s.add_dependency("sprockets", ["~> 2.12.1"])
-  s.add_dependency("sprockets-sass", ["~> 1.2.0"])
+  s.add_dependency("sprockets-sass", ["~> 1.3.0"])
   s.add_dependency("sprockets-helpers", ["~> 1.1.0"])
 end

data/spec/asset_spec.rb

@@ -1,125 +1,118 @@
 # encoding: utf-8
-RSpec.describe Asset do
-  context '#has_type?' do
-    it 'finds type by extension' do
-      asset = Asset.new('/source/path/to/image.png', source_directory: '/source/path/to')
-      expect(asset).to have_type :image
-    end
+RSpec.describe Middleman::Sprockets::Asset do
+
+  def build_subject_asset logical_path, source_dir
+    source_path = File.join source_dir, logical_path
+    @sprockets_double = instance_double("Middleman::Sprockets::Environment")
+    @app_double = double("Middleman::Application",
+                         sprockets: @sprockets_double,
+                         config: ::Middleman::Util.recursively_enhance(images_dir: 'images'))
+    @asset_double = instance_double("Sprockets::BundledAsset",
+                                    pathname: Pathname.new(source_path),
+                                    logical_path: logical_path)
+    allow( @sprockets_double ).to receive(:resolve).with(source_path)
+                                                  .and_return("anything")
+    allow( @sprockets_double ).to receive(:[]).with("anything")
+                                              .and_return(@asset_double)
+
+    return described_class.new @app_double, source_path
+  end
 
-    it 'finds type by path' do
-      asset = Asset.new('/source/path/to/images/image.xz', source_directory: '/source/path/to/images')
-      expect(asset).to have_type :image
-    end
+  describe "#initialize" do
+    it "raises Sprockets::FileNotFound if sprockets can't find the asset" do
+      source_path = "/path/to/nowhere.jpg"
 
-    it 'finds type by double extension' do
-      asset = Asset.new('/source/path/to/image.png.xz', source_directory: '/source/path/to')
-      expect(asset).to have_type :image
-    end
+      @sprockets_double = instance_double("Middleman::Sprockets::Environment")
+      @app_double = double("Middleman::Application",
+                           sprockets: @sprockets_double)
+      allow( @sprockets_double ).to receive(:resolve).with(source_path)
+                                                    .and_return("anything")
 
-    it 'finds type in an unlimited number of extensions' do
-      asset = Asset.new('/source/path/to/image.asdf.png.asdf.xz', source_directory: '/source/path/to')
-      expect(asset).to have_type :image
+      # mimic sprockets unable to find an asset
+      allow( @sprockets_double ).to receive(:[]).with("anything")
+                                                .and_return(nil)
+
+      expect {
+        described_class.new @app_double, source_path
+      }.to raise_error Sprockets::FileNotFound
     end
   end
 
-  context '#import?, #import_it' do
-    it 'fails if file does not exist' do
-      in_current_dir do
-        base_path = File.expand_path('source/path/to')
-        file_path = File.expand_path('source/path/to/image.xz')
+  describe "#type" do
 
-        asset = Asset.new(file_path, source_directory: base_path)
-
-        expect(asset).not_to be_import
-      end
-    end
+    it 'finds type by extension' do
+      image = build_subject_asset 'path/to/image.png', 'source'
+      expect( image.type ).to eq :image
 
-    it 'succeeds if import it is set' do
-      in_current_dir do
-        base_path = File.expand_path('source/path/to')
-        file_path = File.expand_path('source/path/to/image.xz')
-        write_file file_path, 'asdf'
+      stylesheet = build_subject_asset 'path/to/stylesheet.css', 'source'
+      expect( stylesheet.type ).to eq :stylesheet
 
-        asset = Asset.new(file_path, source_directory: base_path)
-        asset.import_it
+      script = build_subject_asset 'path/to/script.js', 'source'
+      expect( script.type ).to eq :script
 
-        expect(asset).to be_import
-      end
+      font = build_subject_asset 'path/to/font.ttf', 'source'
+      expect( font.type ).to eq :font
     end
 
-    it 'succeeds if is in trusted directory images' do
-      in_current_dir do
-        base_path = File.expand_path('source/path/to/images')
-        file_path = File.expand_path('source/path/to/images/image.xz')
-        write_file file_path, 'asdf'
-
-        asset = Asset.new(file_path, source_directory: base_path)
-
-        expect(asset).to be_import
-      end
+    it 'finds type by path' do
+      image = build_subject_asset 'path/to/images/image.foo', 'source'
+      expect( image.type ).to eq :image
+      image = build_subject_asset 'path/to/image.foo', 'images'
+      expect( image.type ).to eq :image
+
+      stylesheet = build_subject_asset 'path/to/css/stylesheet.foo', 'source'
+      expect( stylesheet.type ).to eq :stylesheet
+      image = build_subject_asset 'path/to/stylesheet.foo', 'css'
+      expect( image.type ).to eq :stylesheet
+
+      script = build_subject_asset 'path/to/javascripts/script.foo', 'source'
+      expect( script.type ).to eq :script
+      image = build_subject_asset 'path/to/script.foo', 'javascripts'
+      expect( image.type ).to eq :script
+
+      font = build_subject_asset 'path/to/fonts/font.foo', 'source'
+      expect( font.type ).to eq :font
+      font = build_subject_asset 'path/to/font.foo', 'fonts'
+      expect( font.type ).to eq :font
     end
-  end
 
-  context '#destination_path, #destination_path=, #destination_directory' do
-    it 'returns @destination_path if set' do
-      in_current_dir do
-        base_path = File.expand_path('source/path/to/images')
-        file_path = File.expand_path('source/path/to/images/image.xz')
+    it 'finds type by double extension' do
+      image = build_subject_asset 'path/to/image.svg.erb', 'source'
+      expect( image.type ).to eq :image
 
-        asset = Asset.new(file_path, source_directory: base_path)
-        asset.destination_path = 'asdf/image.xz'
+      stylesheet = build_subject_asset 'path/to/stylesheet.css.scss', 'source'
+      expect( stylesheet.type ).to eq :stylesheet
 
-        expect(asset.destination_path).to eq Pathname.new('asdf/image.xz')
-      end
+      script = build_subject_asset 'path/to/script.js.coffee', 'source'
+      expect( script.type ).to eq :script
     end
 
-    it 'builds path based on destination_directory and relative file path' do
-      in_current_dir do
-        base_path = File.expand_path('source/path/to/images')
-        file_path = File.expand_path('source/path/to/images/image.xz')
-
-        asset = Asset.new(file_path, source_directory: base_path)
-        asset.destination_directory = '/images'
-
-        expect(asset.destination_path.to_s).to eq '/images/image.xz'
-      end
+    it 'finds type in an unlimited number of extensions' do
+      asset = script = build_subject_asset 'path/to/image.asdf.png.asdf.xz', 'source'
+      expect( asset.type ).to eq :image
     end
+  end
 
-    it 'fails if destination_directory and @destination_path are not set' do
-      in_current_dir do
-        base_path = File.expand_path('source/path/to/images')
-        file_path = File.expand_path('source/path/to/images/image.xz')
-
-        asset = Asset.new(file_path, source_directory: base_path)
+  describe "#source_path" do
+    it "returns pathname from sprockets asset" do
+      asset = build_subject_asset 'path/to/asset.css', 'source'
+      expect( @asset_double ).to receive(:pathname)
+                             .and_return("sprockets/pathname")
 
-        expect { 
-          asset.destination_path
-        }.to raise_error ::Sprockets::FileNotFound
-      end
+      expect( asset.source_path ).to eq "sprockets/pathname"
     end
   end
 
-  context '#match?' do
-    it 'success if source path is equal' do
-      in_current_dir do
-        base_path = File.expand_path('source/path/to')
-        file_path = File.expand_path('source/path/to/images/image.xz')
-
-        asset1 = Asset.new(file_path, source_directory: base_path)
-
-        expect(asset1).to be_match file_path
-      end
+  describe "#destination_path" do
+    it "builds path based on asset type" do
+      asset = build_subject_asset 'path/to/image.png', 'source'
+      expect( asset.destination_path.to_s ).to eq 'images/path/to/image.png'
     end
 
-    it 'fails if source path is not equal' do
-      in_current_dir do
-        base_path = File.expand_path('source/path/to')
-        file_path = File.expand_path('source/path/to/images/image.xz')
-
-        asset1 = Asset.new(file_path, source_directory: base_path)
-
-        expect(asset1).not_to be_match 'asdf'
-      end
+    it "strips asset type directory from logical path and uses apps asset directory" do
+      asset = build_subject_asset 'img/path/to/image.png', 'source'
+      expect( asset.destination_path.to_s ).to eq 'images/path/to/image.png'
     end
   end
+
 end

data/spec/imported_asset_spec.rb

@@ -1,72 +1,42 @@
 # encoding: utf-8
-RSpec.describe ImportedAsset do
-  context '#output_path' do
-    it 'uses block as second argument on initialize to get path' do
-      asset = ImportedAsset.new 'source/to/asset/image.png', proc { 'hello/world.png' }
+RSpec.describe Middleman::Sprockets::ImportedAsset do
 
-      expect(asset.output_path.to_s).to eq 'hello/world.png'
+  describe "#initialize" do
+    it "sets #logical_path to a pathname based on given path" do
+      subject = described_class.new "logical"
+      expect( subject.logical_path ).to eq Pathname.new("logical")
     end
-  end
-
-  context '#resolve_path_with' do
-    it 'resolves path' do
-      in_current_dir do
-        relative_path = 'source/path/to/image.xz'
-        file_path = File.expand_path(relative_path)
-
-        resolver = double('Environment')
-        expect(resolver).to receive(:resolve).with(Pathname.new(relative_path)).and_return file_path 
 
-        asset = ImportedAsset.new relative_path
-        asset.resolve_path_with resolver
-      end
+    it "sets #output_path to nil if no block given" do
+      subject = described_class.new "logical"
+      expect( subject.output_path ).to be_nil
     end
 
-    it 'raises an error if path could not be resolved' do
-      in_current_dir do
-        relative_path = 'source/path/to/image.xz'
-
-        resolver = double('Environment')
-        allow(resolver).to receive(:resolve).with(Pathname.new(relative_path)).and_return nil
-
-        asset = ImportedAsset.new relative_path
-
-        expect {
-          asset.resolve_path_with resolver
-        }.to raise_error ::Sprockets::FileNotFound
-      end
+    it "sets #output_path based on return of passed block" do
+      subject = described_class.new "logical", -> { "hello" }
+      expect( subject.output_path ).to eq Pathname.new("hello")
     end
-  end
-
-  context '#match?' do
-    it 'succeeds if real path matches' do
-      in_current_dir do
-        relative_path = 'source/path/to/image.xz'
-        file_path = File.expand_path(relative_path)
-
-        resolver = double('Environment')
-        allow(resolver).to receive(:resolve).and_return file_path
 
-        asset = ImportedAsset.new relative_path
-        asset.resolve_path_with resolver
+    it "passes #logical_path to the output_path block if it accepts an argument" do
+      output_double = proc { |arg| "hello" }
+      expect( output_double ).to receive(:call).with(Pathname.new("logical"))
 
-        expect(asset).to be_match file_path
-      end
+      described_class.new "logical", output_double
     end
 
-    it 'fails if does not match' do
-      in_current_dir do
-        relative_path = 'source/path/to/image.xz'
-        file_path = File.expand_path(relative_path)
+    it "passes #logical_path to the output_path block if it accepts an argument and has a default", skip: '1.9' do
+      output_double = lambda { |arg=3| "hello" }
+      expect( output_double ).to receive(:call).with(Pathname.new("logical"))
 
-        resolver = double('Environment')
-        allow(resolver).to receive(:resolve).and_return file_path + 'fail'
+      described_class.new "logical", output_double
+    end
 
-        asset = ImportedAsset.new relative_path
-        asset.resolve_path_with resolver
+    it "calls output_path block with no args it it accepts none" do
+      output_double = -> { "hello" }
+      expect( output_double ).to receive(:call).with no_args()
 
-        expect(asset).not_to be_match file_path
-      end
+      described_class.new "logical", output_double
     end
   end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: middleman-sprockets
 version: !ruby/object:Gem::Version
-  version: 3.3.10
+  version: 3.4.1
 platform: ruby
 authors:
 - Thomas Reynolds
@@ -10,62 +10,62 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-06 00:00:00.000000000 Z
+date: 2014-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: middleman-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.3'
 - !ruby/object:Gem::Dependency
   name: sprockets
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.12.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 2.12.1
 - !ruby/object:Gem::Dependency
   name: sprockets-sass
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 1.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 1.3.0
 - !ruby/object:Gem::Dependency
   name: sprockets-helpers
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.1.0
 description: Sprockets support for Middleman
@@ -77,10 +77,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .simplecov
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".simplecov"
+- ".travis.yml"
 - CHANGELOG.md
 - CONTRIBUTING.md
 - Gemfile
@@ -212,6 +212,10 @@ files:
 - fixtures/sprockets-images-app/source/index.html.erb
 - fixtures/sprockets-images-app/source/library/images/cat.jpg
 - fixtures/sprockets-images-app/vendor/assets/images/cat-2.jpg
+- fixtures/sprockets-imported-asset-path-conflicts-app/config.rb
+- fixtures/sprockets-imported-asset-path-conflicts-app/resources/assets/stylesheets/test.css
+- fixtures/sprockets-imported-assets-match-multiple-paths-app/config.rb
+- fixtures/sprockets-imported-assets-match-multiple-paths-app/vendor/assets/css/test.css
 - fixtures/sprockets-multiple-extensions-app/bower.json
 - fixtures/sprockets-multiple-extensions-app/config.rb
 - fixtures/sprockets-multiple-extensions-app/source/fonts/fontawesome-webfont-source.svg.gz
@@ -230,16 +234,15 @@ files:
 - fixtures/sprockets-svg-font-app/vendor/assets/components/font-awesome/fonts/fontawesome-webfont-bower.ttf.gz
 - lib/middleman-sprockets.rb
 - lib/middleman-sprockets/asset.rb
-- lib/middleman-sprockets/asset_list.rb
 - lib/middleman-sprockets/asset_tag_helpers.rb
 - lib/middleman-sprockets/config_only_environment.rb
 - lib/middleman-sprockets/environment.rb
 - lib/middleman-sprockets/extension.rb
 - lib/middleman-sprockets/imported_asset.rb
 - lib/middleman-sprockets/sass_function_hack.rb
+- lib/middleman-sprockets/sass_utils.rb
 - lib/middleman-sprockets/version.rb
 - middleman-sprockets.gemspec
-- spec/asset_list_spec.rb
 - spec/asset_spec.rb
 - spec/imported_asset_spec.rb
 - spec/spec_helper.rb
@@ -255,12 +258,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
@@ -395,6 +398,10 @@ test_files:
 - fixtures/sprockets-images-app/source/index.html.erb
 - fixtures/sprockets-images-app/source/library/images/cat.jpg
 - fixtures/sprockets-images-app/vendor/assets/images/cat-2.jpg
+- fixtures/sprockets-imported-asset-path-conflicts-app/config.rb
+- fixtures/sprockets-imported-asset-path-conflicts-app/resources/assets/stylesheets/test.css
+- fixtures/sprockets-imported-assets-match-multiple-paths-app/config.rb
+- fixtures/sprockets-imported-assets-match-multiple-paths-app/vendor/assets/css/test.css
 - fixtures/sprockets-multiple-extensions-app/bower.json
 - fixtures/sprockets-multiple-extensions-app/config.rb
 - fixtures/sprockets-multiple-extensions-app/source/fonts/fontawesome-webfont-source.svg.gz

data/lib/middleman-sprockets/asset_list.rb

@@ -1,37 +0,0 @@
-# encoding: utf-8
-module Middleman
-  module Sprockets
-    class AssetList
-      attr_reader :assets
-
-      def initialize(assets = [])
-        @assets = Array(assets)
-      end
-
-      # Find candidate in list
-      #
-      # @param [#source_path] candidate
-      #   The candidate to search for
-      #
-      # @yield
-      #   This blocks gets the candidate found
-      def lookup(candidate, &block)
-        found_asset = assets.find { |a| a.match? candidate.source_path }
-
-        block.call(candidate, found_asset) if block_given? && found_asset
-
-        found_asset
-      end
-
-      # Append asset to list
-      #
-      # @param [Asset]
-      #   The asset to be appended
-      def add(asset)
-        assets << asset
-      end
-      alias_method :<<, :add
-
-    end
-  end
-end

data/spec/asset_list_spec.rb

@@ -1,38 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe AssetList do
-  context '#add' do
-    it 'adds an asset to the list' do
-      asset = instance_double 'Middleman::Sprockets::Asset'
-      list  = AssetList.new
-
-      expect {
-        list << asset
-      }.not_to raise_error
-    end
-  end
-  context '#lookup' do
-    it 'finds an asset in list' do
-      asset = instance_double 'Middleman::Sprockets::Asset'
-      expect(asset).to receive(:source_path).and_return 'path/to/source'
-      expect(asset).to receive(:match?).and_return true
-
-      list  = AssetList.new
-      list << asset
-
-      expect(list.lookup(asset)).to be asset
-    end
-
-    it 'supports a block which gets the found asset passed' do
-      asset = instance_double 'Middleman::Sprockets::Asset'
-      allow(asset).to receive(:source_path).and_return 'path/to/source'
-      expect(asset).to receive(:destination_path=).with 'path/to/source'
-      expect(asset).to receive(:match?).and_return true
-
-      list  = AssetList.new
-      list << asset
-
-      list.lookup(asset) { |candidate, found_asset| found_asset.destination_path = found_asset.source_path }
-    end
-  end
-end