middleman-sprockets-cj 3.3.6

data/lib/middleman-sprockets/extension.rb

@@ -0,0 +1,145 @@
+require "sprockets"
+require "sprockets-sass"
+require "middleman-sprockets/pathname_extensions"
+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"
+
+# Sprockets extension
+module Middleman
+  class SprocketsExtension < Extension
+    option :debug_assets, false, 'Split up each required asset into its own script/style tag instead of combining them (development only)'
+
+    attr_reader :environment
+
+    # This module gets mixed into both the Middleman instance and the Middleman class,
+    # so that it's available in config.rb
+    module SprocketsAccessor
+      # The sprockets environment
+      # @return [Middleman::MiddlemanSprocketsEnvironment]
+      def sprockets
+        extensions[:sprockets].environment
+      end
+    end
+
+    def initialize(app, options_hash={}, &block)
+      require "middleman-sprockets/sass_function_hack"
+
+      super
+
+      # Start out with a stub environment that can only be configured (paths and such)
+      @environment = ::Middleman::Sprockets::ConfigOnlyEnvironment.new
+
+      app.send :include, SprocketsAccessor
+    end
+
+    helpers do
+      include SprocketsAccessor
+      include ::Middleman::Sprockets::AssetTagHelpers
+    end
+
+    def after_configuration
+      ::Tilt.register ::Sprockets::EjsTemplate, 'ejs'
+      ::Tilt.register ::Sprockets::EcoTemplate, 'eco'
+      ::Tilt.register ::Sprockets::JstProcessor, 'jst'
+
+      app.template_extensions :jst => :js, :eco => :js, :ejs => :js
+
+      if app.config.defines_setting?(:debug_assets) && !options.setting(:debug_assets).value_set?
+        options[:debug_assets] = app.config[:debug_assets]
+      end
+
+      config_environment = @environment
+      debug_assets = !app.build? && options[:debug_assets]
+      @environment = ::Middleman::Sprockets::Environment.new(app, :debug_assets => debug_assets)
+      config_environment.apply_to_environment(@environment)
+
+      append_paths_from_gems
+
+      # Setup Sprockets Sass options
+      if app.config.defines_setting?(:sass)
+        app.config[:sass].each { |k, v| ::Sprockets::Sass.options[k] = v }
+      end
+
+      # Intercept requests to /javascripts and /stylesheets and pass to sprockets
+      our_sprockets = self.environment
+
+      [app.config[:js_dir], app.config[:css_dir], app.config[:images_dir], app.config[:fonts_dir]].each do |dir|
+        app.map("/#{dir}") { run our_sprockets }
+      end
+    end
+
+    # 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?
+
+          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
+
+          new_path = @app.sitemap.extensionless_path(asset.destination_path.to_s)
+
+          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
+      end
+      resources + resources_list
+    end
+
+    private
+
+    # Add any directories from gems with Rails-like paths to sprockets load path
+    def append_paths_from_gems
+      try_paths = [
+                   %w{ assets },
+                   %w{ app },
+                   %w{ app assets },
+                   %w{ vendor },
+                   %w{ vendor assets },
+                   %w{ lib },
+                   %w{ lib assets }
+                  ].inject([]) do |sum, v|
+        sum + [
+               File.join(v, 'javascripts'),
+               File.join(v, 'stylesheets'),
+               File.join(v, 'images'),
+               File.join(v, 'fonts')
+              ]
+      end
+
+      ([app.root] + ::Middleman.rubygems_latest_specs.map(&:full_gem_path)).each do |root_path|
+        try_paths.map {|p| File.join(root_path, p) }.
+          select {|p| File.directory?(p) }.
+          each {|path| self.environment.append_path(path) }
+      end
+    end
+  end
+end

data/lib/middleman-sprockets/imported_asset.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+module Middleman
+  module Sprockets
+    # ImportedAsset 
+    class ImportedAsset
+      attr_reader :logical_path, :output_path, :real_path
+
+      # 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(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
+
+      private
+
+      def has_real_path?(path)
+        real_path == path
+      end
+    end
+  end
+end

data/lib/middleman-sprockets/pathname_extensions.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+class Pathname
+  def start_with?(*paths)
+    to_s.start_with?(*paths)
+  end
+
+  def end_with?(*paths)
+    to_s.end_with?(*paths)
+  end
+end

data/lib/middleman-sprockets/sass_function_hack.rb

@@ -0,0 +1,9 @@
+if defined?(Sass)
+  module Sass::Script::Functions
+    # Override generated_image_url to use Sprockets
+    # a la https://github.com/Compass/compass-rails/blob/master/lib/compass-rails/patches/4_0.rb
+    def generated_image_url(path, only_path = nil)
+      asset_url(path, Sass::Script::String.new("image"))
+    end
+  end
+end

data/lib/middleman-sprockets/version.rb

@@ -0,0 +1,5 @@
+module Middleman
+  module Sprockets
+    VERSION = "3.3.6"
+  end
+end

data/middleman-sprockets.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "middleman-sprockets/version"
+
+Gem::Specification.new do |s|
+  s.name = "middleman-sprockets-cj"
+  s.version = Middleman::Sprockets::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ['Thomas Reynolds', 'Ben Hollis', 'Karl Freeman']
+  s.email = ['me@tdreyno.com', 'ben@benhollis.net', 'karlfreeman@gmail.com']
+  s.homepage = "https://github.com/middleman/middleman-sprockets"
+  s.summary = %q{Sprockets support for Middleman}
+  s.description = %q{Sprockets support for Middleman}
+  s.license = "MIT"
+  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-cj", ["~> 3.3"])
+  s.add_dependency("sprockets", ["~> 2.12.1"])
+  s.add_dependency("sprockets-sass", ["~> 1.2.0"])
+  s.add_dependency("sprockets-helpers", ["~> 1.1.0"])
+end

data/spec/asset_list_spec.rb

@@ -0,0 +1,38 @@
+# 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

data/spec/asset_spec.rb

@@ -0,0 +1,116 @@
+# 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
+
+    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
+  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')
+
+        asset = Asset.new(file_path, source_directory: base_path)
+
+        expect(asset).not_to be_import
+      end
+    end
+
+    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'
+
+        asset = Asset.new(file_path, source_directory: base_path)
+        asset.import_it
+
+        expect(asset).to be_import
+      end
+    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
+    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')
+
+        asset = Asset.new(file_path, source_directory: base_path)
+        asset.destination_path = 'asdf/image.xz'
+
+        expect(asset.destination_path).to eq Pathname.new('asdf/image.xz')
+      end
+    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
+    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)
+
+        expect { 
+          asset.destination_path
+        }.to raise_error ::Sprockets::FileNotFound
+      end
+    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
+    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
+    end
+  end
+
+end

data/spec/imported_asset_spec.rb

@@ -0,0 +1,72 @@
+# 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' }
+
+      expect(asset.output_path.to_s).to eq 'hello/world.png'
+    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
+    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
+    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
+
+        expect(asset).to be_match file_path
+      end
+    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)
+
+        resolver = double('Environment')
+        allow(resolver).to receive(:resolve).and_return file_path + 'fail'
+
+        asset = ImportedAsset.new relative_path
+        asset.resolve_path_with resolver
+
+        expect(asset).not_to be_match file_path
+      end
+    end
+  end
+end