middleman-sprockets 4.0.0.beta.1 → 4.0.0.rc.1

data/fixtures/sprockets-app-debug-assets/config.rb

@@ -1 +0,0 @@
-set :debug_assets, true

data/fixtures/sprockets-app-debug-assets/source/index.html.erb

@@ -1,8 +0,0 @@
-<%= javascript_include_tag "main", :data => { :name => "main" } %>
-<%= javascript_include_tag "//domain.com/script.js" %>
-<%= javascript_include_tag "http://domain.com/script.js" %>
-<%= javascript_include_tag "https://domain.com/script.js" %>
-<%= stylesheet_link_tag "app" %>
-<%= stylesheet_link_tag "//domain.com/styles.css" %>
-<%= stylesheet_link_tag "http://domain.com/styles.css" %>
-<%= stylesheet_link_tag "https://domain.com/styles.css" %>

data/fixtures/sprockets-app-debug-assets/source/javascripts/dependency1.js

@@ -1,3 +0,0 @@
-//= require dependency2
-
-function dependency1() {}

data/fixtures/sprockets-app-debug-assets/source/javascripts/dependency2.js

@@ -1 +0,0 @@
-function dependency2() {}

data/fixtures/sprockets-app-debug-assets/source/javascripts/main.js

@@ -1,4 +0,0 @@
-//= require dependency1
-//= require bootstrap
-
-function main() {}

data/fixtures/sprockets-app-debug-assets/source/stylesheets/app.css.scss

@@ -1,4 +0,0 @@
-//= require_self
-//= require "dependency1"
-//= require "dependency2.css.scss"
-body{margin:0px}

data/lib/middleman-sprockets/asset.rb

@@ -1,142 +0,0 @@
-# encoding: utf-8
-module Middleman
-  module Sprockets
-
-    class Asset
-
-      attr_reader :app, :sprockets, :asset
-
-      def initialize app, lookup_path, sprockets = app.sprockets
-        @app       = app
-        @sprockets = sprockets
-        @asset     = sprockets[ sprockets.resolve(lookup_path) ]
-
-        raise ::Sprockets::FileNotFound, "Couldn't find asset '#{lookup_path}'" if @asset.nil?
-      end
-
-      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
-
-      def source_dir
-        @source_dir ||= source_path.sub /\/?#{asset.logical_path}$/, ''
-      end
-
-      def source_path
-        asset.pathname
-      end
-
-      def exist?
-        File.exist?(asset.pathname)
-      end
-
-      def type
-        @type ||= if is_image?
-                    :image
-                  elsif is_script?
-                    :script
-                  elsif is_stylesheet?
-                    :stylesheet
-                  elsif is_font?
-                    :font
-                  else
-                    :unknown
-                  end
-      end
-
-      private
-
-      def has_extname? *exts
-        !(exts & asset.pathname.to_s.scan(/(\.[^.]+)/).flatten).empty?
-      end
-
-      def remove_asset_dir pathname, asset_dir_paths
-        pathname.sub(/^(#{asset_dir_paths.map { |p| Regexp.new(p) }.join('|')})\/?/, '')
-      end
-
-      def is_image?
-        is_image_by_path? || (is_image_by_extension? && !is_font_by_path?)
-      end
-
-      def is_image_by_path?
-        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?
-
-      def is_image_by_extension?
-        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 stylesheet_paths
-        %w( stylesheets css )
-      end
-
-      def is_font?
-        is_font_by_path? || is_font_by_extension?
-      end
-
-      def is_font_by_path?
-        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?
-
-      def is_font_by_extension?
-        has_extname?(*%w(.ttf .woff .woff2 .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?
-        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/asset_tag_helpers.rb

@@ -1,54 +0,0 @@
-module Middleman
-  module Sprockets
-    module AssetTagHelpers
-
-      # extend padrinos javascript_include_tag with debug functionality
-      # splits up script dependencies in individual files when
-      # configuration variable :debug_assets is set to true
-      def javascript_include_tag(*sources)
-        if sprockets.debug_assets
-          options = sources.extract_options!.symbolize_keys
-          sources.map do |source|
-            super(dependencies_paths('.js', source), options)
-          end.join("").gsub("body=1.js", "body=1")
-        else
-          super
-        end
-      end
-
-      # extend padrinos stylesheet_link_tag with debug functionality
-      # splits up stylesheets dependencies in individual files when
-      # configuration variable :debug_assets is set to true
-      def stylesheet_link_tag(*sources)
-        if sprockets.debug_assets
-          options = sources.extract_options!.symbolize_keys
-          sources.map do |source|
-            super(dependencies_paths('.css', source), options)
-          end.join("").gsub("body=1.css", "body=1")
-        else
-          super
-        end
-      end
-
-      private
-
-      # Find the paths for all the dependencies of a given source file.
-      def dependencies_paths(extension, source)
-        source_file_name = source.to_s
-
-        if source_file_name.start_with?('//', 'http')
-          # Don't touch external sources
-          source_file_name
-        else
-          source_file_name << extension unless source_file_name.end_with?(extension)
-
-          dependencies_paths = sprockets[source_file_name].to_a.map do |dependency|
-            # if sprockets sees "?body=1" it only gives back the body
-            # of the script without the dependencies included
-            dependency.logical_path + "?body=1"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/middleman-sprockets/config_only_environment.rb

@@ -1,50 +0,0 @@
-module Middleman
-  module Sprockets
-    # A fake Sprockets environment that just exposes the
-    # waits to create the environment until asked, but can still
-    # service most of the interesting configuration methods. This
-    # allows sprockets to be configured any time in config.rb, rather
-    # than having to use an after_configuration block.
-    class ConfigOnlyEnvironment
-      attr_reader :imported_assets
-      attr_reader :appended_paths
-      attr_reader :prepended_paths
-
-      def initialize(options={})
-        @imported_assets = []
-        @appended_paths = []
-        @prepended_paths = []
-      end
-
-      def method_missing?(method)
-        raise NoMethodError, "The Sprockets environment is not ready yet, so you can't call #{method} on it. If you need to call this method do it in a 'ready' block."
-      end
-
-      def apply_to_environment(environment)
-        @imported_assets.each do |(path, directory)|
-          environment.import_asset path, &directory
-        end
-
-        @appended_paths.each do |path|
-          environment.append_path path
-        end
-
-        @prepended_paths.each do |path|
-          environment.prepend_path path
-        end
-      end
-
-      def import_asset(asset_logical_path, &output_directory)
-        @imported_assets << [asset_logical_path, output_directory]
-      end
-
-      def append_path(path)
-        @appended_paths << path
-      end
-
-      def prepend_path(path)
-        @prepended_paths << path
-      end
-    end
-  end
-end

data/lib/middleman-sprockets/environment.rb

@@ -1,293 +0,0 @@
-require "middleman-sprockets/asset"
-
-module Middleman
-  module Sprockets
-    # Generic Middleman Sprockets env
-    class Environment < ::Sprockets::Environment
-      # Whether or not we should debug assets by splitting them all out into individual includes
-      attr_reader :debug_assets
-
-      # A list of Sprockets logical paths for assets that should be brought into the
-      # Middleman application and built.
-      attr_reader :imported_assets
-
-      # The current path, useful when inside helper methods
-      attr_reader :last_request_path
-
-      # Setup
-      def initialize(app, options={})
-        @imported_assets = []
-        @app = app
-        @debug_assets = options.fetch(:debug_assets, false)
-
-        super app.source_dir
-
-        # By default, sprockets has no cache! Give it an in-memory one using a Hash
-        # There is also a Sprockets::Cache::FileStore option, but it is fraught with cache-invalidation
-        # peril, so we choose not to use it.
-        @cache = FakeCache.new
-
-        enhance_context_class!
-
-        # Remove compressors, we handle these with middleware
-        unregister_bundle_processor 'application/javascript', :js_compressor
-        unregister_bundle_processor 'text/css', :css_compressor
-
-        # configure search paths
-        append_path app.config[:js_dir]
-        append_path app.config[:css_dir]
-        append_path app.config[:images_dir]
-        append_path app.config[:fonts_dir]
-
-        if app.config.respond_to?(:bower_dir)
-          warn ":bower_dir is deprecated. Call sprockets.append_path from a 'ready' block instead."
-          append_path app.config[:bower_dir]
-        end
-
-        # add custom assets paths to the scope
-        app.config[:js_assets_paths].each do |p|
-          warn ":js_assets_paths is deprecated. Call sprockets.append_path from a 'ready' block instead."
-          append_path p
-        end if app.config.respond_to?(:js_assets_paths)
-
-        # Stylus support
-        if defined?(::Stylus)
-          require 'stylus/sprockets'
-          ::Stylus.setup(self, app.config[:styl])
-        end
-      end
-
-      # Make sure all the defined imported assets still exist
-      def prune_imported_assets!
-        @imported_assets = @imported_assets.select do |a|
-          begin
-            a = Middleman::Sprockets::Asset.new(@app, a.logical_path, self)
-            a.exist?
-          rescue
-            false
-          end
-        end
-      end
-
-      # Add our own customizations to the Sprockets context class
-      def enhance_context_class!
-        app = @app
-        env = self
-
-        # Make the app context available to Sprockets
-        context_class.send(:define_method, :app) { app }
-        context_class.send(:define_method, :env) { env }
-
-        context_class.class_eval do
-          def asset_path(path, options={})
-            # Handle people calling with the Middleman/Padrino asset path signature
-            if path.is_a?(::Symbol) && !options.is_a?(::Hash)
-              kind = path
-              path = options
-            else
-
-            kind = case options[:type]
-                   when :image then :images
-                   when :font then :fonts
-                   when :javascript then :js
-                   when :stylesheet then :css
-                   else options[:type]
-                   end
-            end
-
-            # If Middleman v4, we don't have a global for current path, so pass it in.
-            if self.env.last_request_path
-              app.asset_path(kind, path, {
-                :current_resource => app.sitemap.find_resource_by_destination_path(
-                  self.env.last_request_path
-                )
-              })
-            else 
-              app.asset_path(kind, path)
-            end
-          end
-
-          # These helpers are already defined in later versions of Sprockets, but we define
-          # them ourself to help older versions and to provide extra options that Sass wants.
-
-          # Expand logical image asset path.
-          def image_path(path, options={})
-            asset_path(path, :type => :image)
-          end
-
-          # Expand logical font asset path.
-          def font_path(path, options={})
-            # Knock .fonts off the end, because Middleman < 3.1 doesn't handle fonts
-            # in asset_path
-            asset_path(path, :type => :font).sub(/\.fonts$/, '')
-          end
-
-          # Expand logical javascript asset path.
-          def javascript_path(path, options={})
-            asset_path(path, :type => :javascript)
-          end
-
-          # Expand logical stylesheet asset path.
-          def stylesheet_path(path, options={})
-            asset_path(path, :type => :stylesheet)
-          end
-
-          def method_missing(*args)
-            name = args.first
-            if app.respond_to?(name)
-              app.send(*args)
-            else
-              super
-            end
-          end
-
-          # Needed so that method_missing makes sense
-          def respond_to?(method, include_private = false)
-            super || app.respond_to?(method, include_private)
-          end
-        end
-      end
-      private :enhance_context_class!
-
-      # Override Sprockets' default digest function to *not*
-      # change depending on the exact Sprockets version. It still takes
-      # into account "version" which is a user-suppliable version
-      # number that can be used to force assets to have a new
-      # hash.
-      def digest
-        @digest ||= Digest::SHA1.new.update(version.to_s)
-        @digest.dup
-      end
-
-      # Strip our custom 8-char hex/sha
-      def path_fingerprint(path)
-        path[/-([0-9a-f]{8})\.[^.]+$/, 1]
-      end
-
-      # Invalidate sitemap when users mess with the sprockets load paths
-      def append_path(path)
-        @app.sitemap.rebuild_resource_list!(:sprockets_paths)
-
-        super
-      end
-
-      def prepend_path(path)
-        @app.sitemap.rebuild_resource_list!(:sprockets_paths)
-
-        super
-      end
-
-      def clear_paths
-        @app.sitemap.rebuild_resource_list!(:sprockets_paths)
-        super
-      end
-
-      def css_exception_response(exception)
-        raise exception if @app.build?
-        super
-      end
-
-      def javascript_exception_response(exception)
-        raise exception if @app.build?
-        super
-      end
-
-      # Never return 304s, downstream may want to manipulate data.
-      def etag_match?(asset, env)
-        false
-      end
-
-      def call(env)
-        # Set the app current path based on the full URL so that helpers work
-        script_name = env['SCRIPT_NAME'].dup
-        script_name.gsub!(/^#{@app.config[:http_prefix]}/i, '') if @app.config[:http_prefix]
-        request_path = URI.decode(File.join(script_name, env['PATH_INFO']))
-        if request_path.respond_to? :force_encoding
-          request_path.force_encoding('UTF-8')
-        end
-        resource = @app.sitemap.find_resource_by_destination_path(request_path)
-
-        if !resource && !debug_assets
-          response = ::Rack::Response.new
-          response.status = 404
-          response.write """<html><body><h1>File Not Found</h1><p>#{request_path}</p>
-        <p>If this is an an asset from a gem, add <tt>sprockets.import_asset '#{File.basename(request_path)}'</tt>
-        to your <tt>config.rb</tt>.</body>"""
-          return response.finish
-        end
-
-        if @app.respond_to?(:current_path=)
-          @app.current_path = request_path
-        else
-          @last_request_path = request_path
-        end
-
-        # Fix https://github.com/sstephenson/sprockets/issues/533
-        if resource && File.basename(resource.path) == 'bower.json'
-          file = ::Rack::File.new nil
-          file.path = if resource.source_file.is_a? String
-            resource.source_file
-          else
-            resource.source_file[:full_path]
-          end
-          response = file.serving({})
-          response[1]['Content-Type'] = resource.content_type
-          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
-
-      # Tell Middleman to build this asset, referenced as a logical path.
-      def import_asset(asset_logical_path, &determine_output_dir)
-        args = []
-        args << asset_logical_path
-        args << determine_output_dir if block_given?
-
-        @imported_assets << ImportedAsset.new(*args)
-
-        @app.sitemap.rebuild_resource_list!(:sprockets_import_asset)
-      end
-
-      # Sprocket 3 API change :(
-      def files_in_paths(load_paths)
-        if self.respond_to?(:each_entry)
-          load_paths.flat_map do |path|
-            output = []
-
-            self.each_entry(path).each do |p|
-              output << [p, path]
-            end
-
-            output
-          end
-        else
-          logical_paths.map do |_, path|
-            found_path = load_paths.find do |load_path|
-              path.start_with?(load_path)
-            end
-
-            if found_path
-              [Pathname(path), found_path]
-            else
-              nil
-            end
-          end.reject(&:nil?)
-        end
-      end
-    end
-
-    class FakeCache < Hash
-      alias_method :_get, :[]
-      alias_method :_set, :[]=
-    end
-  end
-end