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

data/fixtures/asset-hash-app/config.rb

@@ -1,3 +1,5 @@
+activate :sprockets
+
 activate :asset_hash
 
 activate :relative_assets

data/fixtures/asset-hash-app/source/stylesheets/jquery-mobile.css.scss

@@ -1 +1,2 @@
 //= require jquery.mobile.theme
+//= require jquery.mobile

data/fixtures/asset-hash-host-app/config.rb

@@ -1,6 +1,6 @@
-
+activate :sprockets
 activate :asset_hash
 activate :directory_indexes
-activate :asset_host
-
-set :asset_host, 'http://middlemanapp.com'
+activate :asset_host do |c|
+  c.host = 'http://middlemanapp.com'
+end

data/fixtures/base-app/config.rb

@@ -0,0 +1 @@
+activate :sprockets

data/fixtures/gems/assets_gem/assets_gem.gemspec

@@ -0,0 +1,16 @@
+Gem::Specification.new do |gem|
+
+  gem.name          = 'assets_gem'
+  gem.version       = '0.0.0'
+  gem.platform      = Gem::Platform::RUBY
+
+  gem.summary       = 'dummy gem for a fixture'
+  gem.description   = %q{ dummy gem for a fixture }
+  gem.authors       = ["Steven Sloan"]
+  gem.email         = ["stevenosloan@gmail.com"]
+  gem.license       = 'MIT'
+
+  gem.files         = Dir["lib/**/*.rb", "vendor/**/*"]
+  gem.require_path  = "lib"
+
+end

data/fixtures/gems/assets_gem/lib/assets_gem.rb

@@ -0,0 +1,7 @@
+module AssetsGem
+  class << self
+    def version
+      '0.0.0'
+    end
+  end
+end

data/fixtures/gems/assets_gem/vendor/assets/css/_imports/_import.scss

@@ -0,0 +1 @@
+$color: #fd0;

data/fixtures/{sprockets-imported-assets-match-multiple-paths-app/vendor/assets/css/test.css → gems/assets_gem/vendor/assets/css/test.scss}

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

data/fixtures/gems/assets_gem/vendor/assets/javascripts/_imports/import.js

@@ -0,0 +1 @@
+alert("imported");

data/gemfiles/middleman-4.0.gemfile

@@ -0,0 +1,7 @@
+root_gemfile = IO.read( File.expand_path('../Gemfile', File.dirname(__FILE__)))
+root_gemfile.sub! "gemspec", 'gemspec path: "../"'
+root_gemfile.sub! "path: 'fixtures/gems/", "path: '../fixtures/gems/"
+
+root_gemfile.sub! "gem 'middleman'", "gem 'middleman', '~> 4.0.0'"
+
+eval root_gemfile, binding

data/gemfiles/middleman-4.1.gemfile

@@ -0,0 +1,7 @@
+root_gemfile = IO.read( File.expand_path('../Gemfile', File.dirname(__FILE__)))
+root_gemfile.sub! "gemspec", 'gemspec path: "../"'
+root_gemfile.sub! "path: 'fixtures/gems/", "path: '../fixtures/gems/"
+
+root_gemfile.sub! "gem 'middleman'", "gem 'middleman', '~> 4.1.0'"
+
+eval root_gemfile, binding

data/gemfiles/middleman-head.gemfile

@@ -0,0 +1,7 @@
+root_gemfile = IO.read( File.expand_path('../Gemfile', File.dirname(__FILE__)))
+root_gemfile.sub! "gemspec", 'gemspec path: "../"'
+root_gemfile.sub! "path: 'fixtures/gems/", "path: '../fixtures/gems/"
+eval root_gemfile, binding
+
+gem 'middleman-cli',  github: 'middleman/middleman', branch: 'master'
+gem 'middleman-core', github: 'middleman/middleman', branch: 'master'

data/gemfiles/sprockets-4.0.gemfile

@@ -0,0 +1,6 @@
+root_gemfile = IO.read( File.expand_path('../Gemfile', File.dirname(__FILE__)))
+root_gemfile.sub! "gemspec", 'gemspec path: "../"'
+root_gemfile.sub! "path: 'fixtures/gems/", "path: '../fixtures/gems/"
+eval root_gemfile, binding
+
+gem 'sprockets', github: 'rails/sprockets'

data/lib/middleman-sprockets.rb

@@ -1,6 +1,6 @@
-require "middleman-core"
+require 'middleman-core'
 
-Middleman::Extensions.register(:sprockets, auto_activate: :before_configuration) do
-  require "middleman-sprockets/extension"
-  Middleman::SprocketsExtension
-end
+Middleman::Extensions.register(:sprockets) do
+  require 'middleman-sprockets/extension'
+  Middleman::Sprockets::Extension
+end

data/lib/middleman-sprockets/extension.rb

@@ -1,257 +1,216 @@
-require "sprockets"
-require "middleman-core/sitemap/resource"
+require 'sprockets'
+require 'middleman-core/contracts'
+require 'middleman-core/sitemap/resource'
 
-module Middleman
-  class SprocketsExtension < Extension
-    attr_reader :environment
-
-    expose_to_config sprockets: :environment
+require_relative 'resource'
+require_relative 'interface'
 
-    def initialize(app, options_hash={}, &block)
-      super
+module Middleman
+  module Sprockets
+    class Extension < Extension
+      attr_reader :environment,
+                  :interface
 
-      @inline_asset_references = Set.new
+      expose_to_config   sprockets: :environment
+      expose_to_template sprockets: :environment
 
-      @environment = ::Sprockets::Environment.new
+      option :supported_output_extensions, ['.css', '.js'], 'Output extensions sprockets should process'
+      option :imported_asset_path,         'assets',        'Where under source imported assets should be placed.'
+      option :expose_middleman_helpers,    false,           'Whether to expose middleman helpers to sprockets.'
 
-      app.config.define_setting :sprockets_imported_asset_path, "assets", "Where under source should imported assets be placed."
-    end
+      Contract ::Middleman::Application, Hash, Maybe[Proc] => Any
+      def initialize app, options_hash={}, &block
+        super
 
-    def after_configuration
-      @environment.append_path((app.source_dir + app.config[:js_dir]).to_s)
-      @environment.append_path((app.source_dir + app.config[:css_dir]).to_s)
+        @inline_asset_references = Set.new
+        @environment             = ::Sprockets::Environment.new
+        @interface               = Interface.new options, @environment
 
-      append_paths_from_gems
+        use_sassc_if_available
+      end
 
-      the_app = app
-      the_env = environment
+      Contract Any
+      def after_configuration
+        @environment.append_path((app.source_dir + app.config[:js_dir]).to_s)
+        @environment.append_path((app.source_dir + app.config[:css_dir]).to_s)
+        @environment.append_path(app.source_dir.to_s)
+
+        append_paths_from_gems
+
+        the_app = app
+        the_env = environment
+
+        @environment.context_class.send(:define_method, :app)  { the_app }
+        @environment.context_class.send(:define_method, :data) { the_app.data }
+        @environment.context_class.send(:define_method, :env)  { the_env }
+
+        @environment.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 = {
+                image: :images,
+                font: :fonts,
+                javascript: :js,
+                stylesheet: :css
+              }.fetch(options[:type], options[:type])
+            end
+
+            if File.extname(path).empty?
+              path << { js: '.js', css: '.css' }.fetch(kind, '')
+            end
+
+            if app.extensions[:sprockets].check_asset(path)
+              app.extensions[:sprockets].sprockets_asset_path(environment[path]).sub(/^\/?/, '/')
+            else
+              app.asset_path(kind, path)
+            end
+          end
+        end
 
-      @environment.context_class.send(:define_method, :app) { the_app }
-      @environment.context_class.send(:define_method, :data) { the_app.data }
-      @environment.context_class.send(:define_method, :env) { the_env }
+        expose_app_helpers_to_sprockets! if options[:expose_middleman_helpers]
+      end
 
-      @environment.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
+      Contract ResourceList => ResourceList
+      def manipulate_resource_list resources
+        sprockets_resources = ::Middleman::Util.instrument 'sprockets', name: 'manipulator.sprockets_resources' do
+          resources.map do |resource|
+            process_candidate_sprockets_resource(resource)
+          end
+        end
 
-          kind = case options[:type]
-                 when :image then :images
-                 when :font then :fonts
-                 when :javascript then :js
-                 when :stylesheet then :css
-                 else options[:type]
-                 end
+        linked_resources = ::Middleman::Util.instrument 'sprockets', name: 'manipulator.linked_resources' do
+          @inline_asset_references.map do |path|
+            asset = environment[path]
+            generate_resource(sprockets_asset_path(asset), asset.filename, asset.logical_path)
           end
+        end
 
-          if app.extensions[:sprockets].check_asset(path)
-            "/#{app.config[:sprockets_imported_asset_path]}/#{path}"
+        ::Middleman::Util.instrument 'sprockets', name: 'manipulator.ignore_resources' do
+          if app.extensions[:sitemap_ignore].respond_to?(:manipulate_resource_list)
+            app.extensions[:sitemap_ignore].manipulate_resource_list sprockets_resources + linked_resources
           else
-            app.asset_path(kind, path)
+            sprockets_resources + linked_resources
           end
         end
       end
-    end
-
-    def base_resource?(r)
-      r.class.ancestors.first == ::Middleman::Sitemap::Resource
-    end
 
-    def js?(r)
-      begin
-        r.source_file.start_with?((app.source_dir + app.config[:js_dir]).to_s)
-      rescue
-        require 'pry'
-        binding.pry
-      end
-    end
-
-    def css?(r)
-      r.source_file.start_with?((app.source_dir + app.config[:css_dir]).to_s)
-    end
-
-    def check_asset(path)
-      if asset = environment[path]
-        @inline_asset_references << path
-        true
-      else
-        false
-      end
-    end
-
-    def manipulate_resource_list(resources)
-      sprockets, non_sprockets = resources.partition do |r|
-        base_resource?(r) && (js?(r) || css?(r))
+      Contract ::Middleman::Sitemap::Resource => Bool
+      def processible? r
+        !r.is_a?(Resource) && interface.processible?(r.source_file)
       end
 
-      non_sprockets + sprockets.reduce([]) do |sum, r|
-        sprockets_path = if js?(r)
-          r.path.sub(%r{^#{app.config[:js_dir]}\/}, '')
+      Contract String => Bool
+      def check_asset path
+        if environment[path]
+          @inline_asset_references << path
+          true
         else
-          r.path.sub(%r{^#{app.config[:css_dir]}\/}, '')
-        end
-
-        sprockets_resource = generate_resource(r.path, r.source_file, sprockets_path)
-        sum << sprockets_resource
-
-        if sprockets_resource.respond_to?(:sprockets_asset)
-          sprockets_resource.sprockets_asset.links.each do |a|
-            asset = environment[a]
-            path = "#{app.config[:sprockets_imported_asset_path]}/#{asset.logical_path}"
-            sum << generate_resource(path, asset.filename, asset.logical_path)
-          end
+          false
         end
+      end
 
-        sum
-      end + @inline_asset_references.map do |path|
-        asset = environment[path]
-        path = "#{app.config[:sprockets_imported_asset_path]}/#{asset.logical_path}"  
-        generate_resource(path, asset.filename, asset.logical_path)
+      Contract ::Sprockets::Asset => String
+      def sprockets_asset_path sprockets_asset
+        File.join(options[:imported_asset_path], sprockets_asset.logical_path)
       end
-    end
 
-    private
+      private
 
-    def generate_resource(path, source_file, sprockets_path)
-      begin
-        SprocketsResource.new(app.sitemap, path, source_file, sprockets_path, environment)
-      rescue Exception => e
-        raise e if app.build?
+        def expose_app_helpers_to_sprockets!
+          @environment.context_class.class_eval do
+            def current_resource
+              logger.error "The use of `current_resource` in sprockets assets isn't currently implemented"
+              nil
+            end
 
-        ext = File.extname(path)
-        error_message = if ext == '.css'
-          css_exception_response(e)
-        elsif ext == '.js'
-          javascript_exception_response(e)
-        else
-          e.to_s
-        end
+            def mm_context
+              @_mm_context ||= app.template_context_class.new(app)
+            end
 
-        ::Middleman::Sitemap::StringResource.new(app.sitemap, path, error_message)
-      end
-    end
+            def method_missing method, *args, &block
+              if mm_context.respond_to?(method)
+                return mm_context.send method, *args, &block
+              end
 
-    # Returns a JavaScript response that re-throws a Ruby exception
-    # in the browser
-    def javascript_exception_response(exception)
-      err  = "#{exception.class.name}: #{exception.message}\n  (in #{exception.backtrace[0]})"
-      "throw Error(#{err.inspect})"
-    end
+              super
+            end
 
-    # Returns a CSS response that hides all elements on the page and
-    # displays the exception
-    def css_exception_response(exception)
-      message   = "\n#{exception.class.name}: #{exception.message}"
-      backtrace = "\n  #{exception.backtrace.first}"
-
-      <<-CSS
-        html {
-          padding: 18px 36px;
-        }
-
-        head {
-          display: block;
-        }
-
-        body {
-          margin: 0;
-          padding: 0;
-        }
-
-        body > * {
-          display: none !important;
-        }
-
-        head:after, body:before, body:after {
-          display: block !important;
-        }
-
-        head:after {
-          font-family: sans-serif;
-          font-size: large;
-          font-weight: bold;
-          content: "Error compiling CSS asset";
-        }
-
-        body:before, body:after {
-          font-family: monospace;
-          white-space: pre-wrap;
-        }
-
-        body:before {
-          font-weight: bold;
-          content: "#{escape_css_content(message)}";
-        }
-
-        body:after {
-          content: "#{escape_css_content(backtrace)}";
-        }
-      CSS
-    end
+            def respond_to? method, include_private=false
+              super || mm_context.respond_to?(method, include_private)
+            end
+          end
+        end
 
-    # Escape special characters for use inside a CSS content("...") string
-    def escape_css_content(content)
-      content.
-        gsub('\\', '\\\\005c ').
-        gsub("\n", '\\\\000a ').
-        gsub('"',  '\\\\0022 ').
-        gsub('/',  '\\\\002f ')
-    end
+        Contract ::Middleman::Sitemap::Resource => Or[::Middleman::Sitemap::Resource, Resource]
+        def process_candidate_sprockets_resource resource
+          return resource unless processible?(resource)
 
-    # 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
+          ::Middleman::Util.instrument 'sprockets', name: 'process_resource', resource: resource do
+            sprockets_resource = generate_resource(resource.path, resource.source_file, resource.path)
 
-    # Add any directories from gems with Rails-like paths to sprockets load path
-    def append_paths_from_gems
-      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]
+            if sprockets_resource.respond_to?(:sprockets_asset) && !sprockets_resource.errored?
+              @inline_asset_references.merge sprockets_resource.sprockets_asset.links
+            end
 
-      root_paths.product(base_paths.product(asset_dirs)).each do |root, (base, asset)|
-        path = File.join(root, base, asset)
-        environment.append_path(path) if File.directory?(path)
-      end
-    end
+            sprockets_resource
+          end
+        rescue => e
+          logger.error("== Sprockets Debug: #{resource}")
+          logger.error("== Sprockets Debug: #{sprockets_resource}") if defined?(sprockets_resource)
+          raise e
+        end
 
-    class SprocketsResource < ::Middleman::Sitemap::Resource
-      def initialize(store, path, source_file, sprockets_path, environment)
-        @path = path
-        @sprockets_path = sprockets_path
-        @environment = environment
-        @source = sprockets_asset.source
+        Contract String, String, String => Resource
+        def generate_resource path, source_file, sprockets_path
+          ::Middleman::Util.instrument 'sprockets', name: 'generate_resource',
+                                                    path: path,
+                                                    sprockets_path: sprockets_path do
+            Resource.new(app.sitemap, path, source_file, sprockets_path, environment)
+          end
+        end
 
-        super(store, path, source_file)
-      end
+        def use_sassc_if_available
+          if defined?(::SassC)
+            require 'sprockets/sassc_processor'
+            environment.register_transformer 'text/sass', 'text/css', ::Sprockets::SasscProcessor.new
+            environment.register_transformer 'text/scss', 'text/css', ::Sprockets::ScsscProcessor.new
 
-      def template?
-        true
-      end
+            logger.info '== Sprockets will render css with SassC'
+          end
+        rescue LoadError
+          logger.info "== Sprockets will render css with ruby sass\n" \
+                      '   consider using Sprockets 4.x to render with SassC'
+        end
 
-      def render(*)
-        @source
-      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 sprockets_asset
-        @environment[@sprockets_path]
-      end
+        # Add any directories from gems with Rails-like paths to sprockets load path
+        def append_paths_from_gems
+          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)
 
-      def binary?
-        false
-      end
+          root_paths.product(base_paths.product(asset_dirs)).each do |root, (base, asset)|
+            path = File.join(root, base, asset)
+            environment.append_path(path) if File.directory?(path)
+          end
+        end
     end
   end
-end
+end