sprockets-sass 1.3.1 → 2.0.0.beta2

data/lib/sprockets/sass/v2/sass_template.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+module Sprockets
+  module Sass
+    module V2
+      # Preprocessor for SASS files
+      class SassTemplate
+        VERSION = '1'
+
+        def self.default_mime_type
+          'text/css'
+        end
+
+        # Internal: Defines default sass syntax to use. Exposed so the ScssProcessor
+        # may override it.
+        def self.syntax
+          :sass
+        end
+
+        # Public: Return singleton instance with default options.
+        #
+        # Returns SassProcessor object.
+        def self.instance
+          @instance ||= new
+        end
+
+        def self.call(input)
+          instance.call(input)
+        end
+
+        def self.cache_key
+          instance.cache_key
+        end
+
+        attr_reader :cache_key, :filename, :source, :context, :options
+
+        def initialize(options = {}, &block)
+          @default_options = { default_encoding: Encoding.default_external || 'utf-8' }
+          initialize_engine
+          if options.is_a?(Hash)
+            instantiate_with_options(options, &block)
+          else
+            instantiate_with_filename_and_source(options, &block)
+          end
+        end
+
+        def instantiate_with_filename_and_source(options)
+          @filename = options
+          @source = block_given? ? yield : nil
+          @options = @default_options
+          @cache_version = VERSION
+          @cache_key = "#{self.class.name}:#{::Sass::VERSION}:#{VERSION}:#{Sprockets::Sass::Utils.digest(options)}"
+          @functions = Module.new do
+            include Sprockets::Helpers if defined?(Sprockets::Helpers)
+            include Sprockets::Sass::Utils.get_class_by_version('Functions')
+          end
+        end
+
+        def instantiate_with_options(options, &block)
+          @cache_version = options[:cache_version] || VERSION
+          @cache_key = "#{self.class.name}:#{::Sass::VERSION}:#{@cache_version}:#{Sprockets::Sass::Utils.digest(options)}"
+          @filename = options[:filename]
+          @source = options[:data]
+          @options = options.merge(@default_options)
+          @importer_class = options[:importer]
+          @sass_config = options[:sass_config] || {}
+          @input = options
+          @functions = Module.new do
+            include Sprockets::Helpers if defined?(Sprockets::Helpers)
+            include Sprockets::Sass::Utils.get_class_by_version('Functions')
+            include options[:functions] if options[:functions]
+            class_eval(&block) if block_given?
+          end
+        end
+
+        @sass_functions_initialized = false
+        class << self
+          attr_accessor :sass_functions_initialized
+          alias sass_functions_initialized? sass_functions_initialized
+          # Templates are initialized once the functions are added.
+          def engine_initialized?
+            sass_functions_initialized?
+          end
+        end
+
+        # Add the Sass functions if they haven't already been added.
+        def initialize_engine
+          return if self.class.engine_initialized?
+
+          if Sass.add_sass_functions != false
+            begin
+              require 'sprockets/helpers'
+              require 'sprockets/sass/functions'
+              self.class.sass_functions_initialized = true
+            rescue LoadError; end
+          end
+        end
+
+        def call(input)
+          @input = input
+          @filename = input[:filename]
+          @source   = input[:data]
+          @context  = input[:environment].context_class.new(input)
+          run
+        end
+
+        def render(context, _empty_hash_wtf)
+          @context = context
+          run
+        end
+
+        def run
+          data = Sprockets::Sass::Utils.read_file_binary(filename, options)
+
+          engine = ::Sass::Engine.new(data, sass_options)
+          css = Sprockets::Sass::Utils.module_include(::Sass::Script::Functions, @functions) do
+            css = engine.render
+          end
+
+          sass_dependencies = Set.new([filename])
+          if context.respond_to?(:metadata)
+            engine.dependencies.map do |dependency|
+              sass_dependencies << dependency.options[:filename]
+              context.metadata[:dependencies] << Sprockets::URIUtils.build_file_digest_uri(dependency.options[:filename])
+            end
+            context.metadata.merge(data: css, sass_dependencies: sass_dependencies)
+          else
+            css
+          end
+
+          #  Tilt::SassTemplate.new(filename, sass_options(filename, context)).render(self)
+        rescue => e
+          # Annotates exception message with parse line number
+          # context.__LINE__ = e.sass_backtrace.first[:line]
+          raise [e, e.backtrace].join("\n")
+        end
+
+        def merge_sass_options(options, other_options)
+          if (load_paths = options[:load_paths]) && (other_paths = other_options[:load_paths])
+            other_options[:load_paths] = other_paths + load_paths
+          end
+          options = options.merge(other_options)
+          options[:load_paths] = options[:load_paths].is_a?(Array) ? options[:load_paths] : []
+          options[:load_paths] = options[:load_paths].concat(context.environment.paths)
+          options
+        end
+
+        def default_sass_config
+          if defined?(Compass)
+            merge_sass_options Compass.sass_engine_options.dup, Sprockets::Sass.options
+          else
+            Sprockets::Sass.options.dup
+          end
+        end
+
+        def default_sass_options
+          sass = default_sass_config
+          sass = merge_sass_options(sass.dup, @sass_config) if defined?(@sass_config) && @sass_config.is_a?(Hash)
+          sass
+        end
+
+        def build_cache_store(context)
+          return nil if context.environment.cache.nil?
+          if defined?(Sprockets::SassProcessor::CacheStore)
+            Sprockets::SassProcessor::CacheStore.new(context.environment)
+          else
+            custom_cache_store(context.environment)
+          end
+        end
+
+        def custom_cache_store(*args)
+          Sprockets::Sass::V2::CacheStore.new(*args)
+        end
+
+        # Allow the use of custom SASS importers, making sure the
+        # custom importer is a `Sprockets::Sass::Importer`
+        def fetch_importer_class
+          if defined?(@importer_class) && !@importer_class.nil?
+            @importer_class
+          elsif default_sass_options.key?(:importer) && default_sass_options[:importer].is_a?(Importer)
+            default_sass_options[:importer]
+          else
+            custom_importer_class
+          end
+        end
+
+        def custom_importer_class(*_args)
+          Sprockets::Sass::V2::Importer.new
+        end
+
+        def fetch_sprockets_options
+          sprockets_options = {
+            context: context,
+            environment: context.environment,
+            dependencies: context.respond_to?(:metadata) ? context.metadata[:dependencies] : []
+          }
+          if context.respond_to?(:metadata)
+            sprockets_options.merge(load_paths: context.environment.paths + default_sass_options[:load_paths])
+          end
+          sprockets_options
+        end
+
+        def sass_options
+          importer = fetch_importer_class
+          sprockets_options = fetch_sprockets_options
+
+          sass = merge_sass_options(default_sass_options, options).merge(
+            filename: filename,
+            line: 1,
+            syntax: self.class.syntax,
+            cache: true,
+            cache_store: build_cache_store(context),
+            importer: importer,
+            custom: { sprockets_context: context },
+            sprockets: sprockets_options
+          )
+          sass
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/sass/v2/scss_template.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Sprockets
+  module Sass
+    module V2
+      # Preprocessor for SCSS files
+      class ScssTemplate < Sprockets::Sass::V2::SassTemplate
+        # Define the expected syntax for the template
+        def self.syntax
+          :scss
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/sass/v3/cache_store.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+module Sprockets
+  module Sass
+    module V3
+      # Internal: Cache wrapper for Sprockets cache adapter. (Sprockets >= 3)
+      class CacheStore < ::Sass::CacheStores::Base
+        VERSION = '1'
+
+        def initialize(cache, version)
+          @cache = cache
+          @version = "#{VERSION}/#{version}"
+        end
+
+        def _store(key, version, sha, contents)
+          @cache.set("#{@version}/#{version}/#{key}/#{sha}", contents, true)
+        end
+
+        def _retrieve(key, version, sha)
+          @cache.get("#{@version}/#{version}/#{key}/#{sha}", true)
+        end
+
+        def path_to(key)
+          key
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/sass/v3/compressor.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Sprockets
+  module Sass
+    module V3
+      # Class used to compress CSS files
+      class Compressor
+        VERSION = '1'
+
+        def self.default_mime_type
+          'text/css'
+        end
+
+        # Public: Return singleton instance with default options.
+        #
+        # Returns SassCompressor object.
+        def self.instance
+          @instance ||= new
+        end
+
+        def self.call(input)
+          instance.call(input)
+        end
+
+        def self.cache_key
+          instance.cache_key
+        end
+
+        attr_reader :cache_key, :input, :filename, :source, :options, :context
+
+        def initialize(options = {})
+          @default_options = {
+            syntax: :scss,
+            cache: false,
+            read_cache: false,
+            style: :compressed,
+            default_encoding: Encoding.default_external || 'utf-8'
+          }
+          @options = @default_options
+          @cache_key = "#{self.class.name}:#{::Sass::VERSION}:#{VERSION}:#{Sprockets::Sass::Utils.digest(options)}"
+          if options.is_a?(Hash)
+            @input = options
+            @filename = options[:filename]
+            @source = options[:data]
+            @options = @options.merge(options)
+          else
+            @filename = options
+            @source = block_given? ? yield : nil
+          end
+        end
+
+        def call(input)
+          @input = input
+          if input.is_a?(Hash)
+            @filename = input[:filename]
+            @source   = input[:data]
+            @context  = input[:environment].context_class.new(input)
+          end
+          data = filename || @input
+          run(data)
+        end
+
+        def render(context, _empty_hash_wtf)
+          @context = context
+          run(filename)
+        end
+
+        def self.compress(input)
+          call(input)
+        end
+
+        def run(string)
+          data = File.exist?(string.to_s) ? Sprockets::Sass::Utils.read_file_binary(string, options) : string
+          if data.count("\n") >= 2
+            engine = ::Sass::Engine.new(data, @options.merge(filename: filename))
+            css = engine.render
+            # this is defined when using sprockets environment,
+            # but is not defined when calling directly in tests
+            # unless using the manifest to compile the assets
+            if defined?(@context) && @context.respond_to?(:metadata)
+              sass_dependencies = Set.new([filename])
+              engine.dependencies.map do |dependency|
+                sass_dependencies << dependency.options[:filename]
+                context.metadata[:dependencies] << Sprockets::URIUtils.build_file_digest_uri(dependency.options[:filename])
+              end
+              context.metadata.merge(data: css, sass_dependencies: sass_dependencies)
+            else
+              css
+            end
+          else
+            data
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/sass/v3/functions.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+require_relative '../v2/functions'
+module Sprockets
+  module Sass
+    module V3
+      # Module used to inject helpers into SASS engine
+      module Functions
+        include Sprockets::Sass::V2::Functions
+      end
+    end
+  end
+end

data/lib/sprockets/sass/v3/importer.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+require_relative '../v2/importer'
+module Sprockets
+  module Sass
+    module V3
+      # class used for importing files from SCCS and SASS files
+      class Importer < Sprockets::Sass::V2::Importer
+        GLOB = /\*|\[.+\]/
+
+        protected
+
+        def resolve_path_with_load_paths(context, path, root_path, file)
+          context.resolve(file.to_s, load_paths: context.environment.paths, base_path: root_path, accept: syntax_mime_type(path))
+        rescue
+          nil
+        end
+
+        # Finds an asset from the given path. This is where
+        # we make Sprockets behave like Sass, and import partial
+        # style paths.
+        def resolve(context, path, base_path)
+          paths, root_path = possible_files(context, path, base_path)
+          paths.each do |file|
+            found_item = resolve_path_with_load_paths(context, path, root_path, file)
+            return found_item if !found_item.nil? && asset_requirable?(context, found_item)
+          end
+          nil
+        end
+
+        def stat_of_pathname(context, _pathname, path)
+          context.environment.stat(path)
+        end
+
+        def available_content_types(path)
+          ['text/css', syntax_mime_type(path), "text/#{syntax(path)}+ruby"].compact.uniq
+        end
+
+        def check_context_content_types(context, path)
+          available_mimes = available_content_types(path)
+          path_content_type, _attributes = content_type_of_path(context, path)
+          context.content_type.nil? || available_mimes.include?(path_content_type) || available_mimes.include?(context.content_type)
+        end
+
+        def asset_requirable?(context, path)
+          pathname = begin
+            context.resolve(path)
+          rescue
+            nil
+          end
+          return false if pathname.nil?
+          stat = stat_of_pathname(context, pathname, path)
+          return false unless stat && stat.file?
+          check_context_content_types(context, path)
+        end
+
+        # Finds all of the assets using the given glob.
+        def resolve_glob(context, glob, base_path)
+          base_path      = Pathname.new(base_path)
+          path_with_glob = base_path.dirname.join(glob).to_s
+
+          Pathname.glob(path_with_glob).sort.select do |path|
+            asset_requirable = asset_requirable?(context, path)
+            path != context.pathname && asset_requirable
+          end
+        end
+
+        # Returns all of the possible paths (including partial variations)
+        # to attempt to resolve with the given path.
+        def possible_files(context, path, base_path)
+          paths, root_path = super(context, path, base_path)
+          paths = additional_paths_for_sprockets(context, paths, path, base_path)
+          [paths.compact, root_path]
+        end
+
+        def additional_paths_for_sprockets(context, paths, path, base_path)
+          relatives = paths.map { |path_detected| path_detected.to_s.start_with?('.') ? Pathname.new(path_detected) : Pathname.new(path_detected.to_s.prepend('./')) }
+          context.environment.paths.each do |load_path|
+            relative_path = Pathname.new(base_path).relative_path_from(Pathname.new(load_path)).join(path)
+            paths.unshift(relative_path, partialize_path(relative_path))
+          end
+          paths = paths.unshift(relatives)
+          paths
+        end
+
+        def filtered_processor_classes
+          classes = super
+          classes << Sprockets::Preprocessors::DefaultSourceMap if defined?(Sprockets::Preprocessors::DefaultSourceMap)
+          classes << Sprockets::SourceMapProcessor if defined?(Sprockets::SourceMapProcessor)
+          classes
+        end
+
+        def content_type_of_path(context, path)
+          attributes = context.environment.send(:parse_path_extnames, path.to_s)
+          content_type = attributes[1]
+          [content_type, attributes]
+        end
+
+        def build_input_for_process(context, path, data)
+          content_type, _attributes = content_type_of_path(context, path)
+          {
+            environment: context.environment,
+            cache: context.environment.cache,
+            uri: path.to_s,
+            filename: path.to_s,
+            load_path: context.environment.paths,
+            name: File.basename(path),
+            content_type: content_type,
+            data: data,
+            metadata: context.metadata
+          }
+        end
+
+        def check_path_before_process(_context, path)
+          path
+        end
+
+        def call_processor_input(processor, context, input, processors)
+          metadata = (input[:metadata] || {}).dup
+          metadata[:data] = input[:data]
+          result = processor.call(input)
+          processors.delete(processor)
+          handle_process_result(context, result, processors, metadata)
+        end
+
+        def handle_complex_process_result(context, result, processors)
+          data = result[:data] if result.key?(:data)
+          context.metadata.merge!(result)
+          context.metadata.delete(:data)
+          if result.key?(:required)
+            result[:required].each do |file|
+              file_asset = context.environment.load(file)
+              data += process(processors, context, file_asset.filename)
+            end
+          end
+          data
+        end
+
+        def handle_process_result(context, result, processors, metadata)
+          data = nil
+          case result
+          when NilClass
+            data = metadata[:data]
+          when Hash
+            data = handle_complex_process_result(context, result, processors)
+          when String
+            data = result
+          else
+            raise Error, "invalid processor return type: #{result.class}"
+          end
+          data
+        end
+
+        # Internal: Run processors on filename and data.
+        #
+        # Returns Hash.
+        def process(processors, context, path)
+          path = check_path_before_process(context, path)
+          data = Sprockets::Sass::Utils.read_template_file(path.to_s)
+          input = build_input_for_process(context, path, data)
+          processors.each do |processor|
+            data = call_processor_input(processor, context, input, processors)
+          end
+
+          data
+        end
+
+        def get_context_preprocessors(context, content_type)
+          context.environment.preprocessors[content_type].map { |a| a.class == Class ? a : a.class }
+        end
+
+        def get_context_transformers(context, content_type, path)
+          available_transformers =  context.environment.transformers[content_type]
+          additional_transformers = available_transformers.key?(syntax_mime_type(path)) ? available_transformers[syntax_mime_type(path)] : []
+          additional_transformers.is_a?(Array) ? additional_transformers : [additional_transformers]
+        end
+
+        def get_engines_from_attributes(context, attributes)
+          engines = []
+          attributes[2].each do |extension|
+            ext = ::Sprockets::Utils.normalize_extension(extension)
+            ext_engines = context.environment.engines[ext]
+            ext_engines = ext_engines.is_a?(Array) ? ext_engines : [ext_engines]
+            engines.concat(ext_engines)
+          end
+          engines
+        end
+
+        def get_all_processors_for_evaluate(context, content_type, attributes, path)
+          engines = get_engines_from_attributes(context, attributes)
+          preprocessors = get_context_preprocessors(context, content_type)
+          additional_transformers = get_context_transformers(context, content_type, path)
+          postprocessors = get_context_postprocessors(context, content_type)
+          engines.reverse + preprocessors + additional_transformers.reverse  + postprocessors
+        end
+
+        def get_context_postprocessors(context, content_type)
+          context.environment.postprocessors[content_type].map { |a| a.class == Class ? a : a.class  }
+        end
+
+        def filter_all_processors(processors)
+          processors.delete_if do |processor|
+            filtered_processor_classes.include?(processor) || filtered_processor_classes.any? do |filtered_processor|
+              !processor.is_a?(Proc) && processor < filtered_processor
+            end
+          end
+        end
+
+        def evaluate_path_from_context(context, path, processors)
+          process(processors, context, path)
+        end
+
+        # Returns the string to be passed to the Sass engine. We use
+        # Sprockets to process the file, but we remove any Sass processors
+        # because we need to let the Sass::Engine handle that.
+        def evaluate(context, path)
+          content_type, attributes = content_type_of_path(context, path)
+          processors = get_all_processors_for_evaluate(context, content_type, attributes, path)
+          filter_all_processors(processors)
+          evaluate_path_from_context(context, path, processors)
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/sass/v3/sass_template.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+require_relative '../v2/sass_template'
+module Sprockets
+  module Sass
+    module V3
+      # Preprocessor for SASS files
+      class SassTemplate < Sprockets::Sass::V2::SassTemplate
+        def build_cache_store(context)
+          return nil if context.environment.cache.nil?
+          cache = @input[:cache]
+          version = @cache_version
+          if defined?(Sprockets::SassProcessor::CacheStore)
+            Sprockets::SassProcessor::CacheStore.new(cache, version)
+          else
+            custom_cache_store(cache, version)
+          end
+        end
+
+        def custom_cache_store(*args)
+          Sprockets::Sass::V3::CacheStore.new(*args)
+        end
+
+        # Allow the use of custom SASS importers, making sure the
+        # custom importer is a `Sprockets::Sass::Importer`
+        def fetch_importer_class
+          if defined?(@importer_class) && !@importer_class.nil?
+            @importer_class
+          elsif default_sass_options.key?(:importer) && default_sass_options[:importer].is_a?(Importer)
+            default_sass_options[:importer]
+          else
+            Sprockets::Sass::V3::Importer.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/sass/v3/scss_template.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+require_relative './sass_template'
+module Sprockets
+  module Sass
+    module V3
+      # Preprocessor for SCSS files
+      class ScssTemplate < Sprockets::Sass::V3::SassTemplate
+        # Define the expected syntax for the template
+        def self.syntax
+          :scss
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/sass/v4/cache_store.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require_relative '../v3/cache_store'
+module Sprockets
+  module Sass
+    module V4
+      # Internal: Cache wrapper for Sprockets cache adapter. (Sprockets >= 3)
+      class CacheStore < Sprockets::Sass::V3::CacheStore
+      end
+    end
+  end
+end

data/lib/sprockets/sass/v4/compressor.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require_relative '../v3/compressor'
+module Sprockets
+  module Sass
+    module V4
+      # Class used to compress CSS files
+      class Compressor < Sprockets::Sass::V3::Compressor
+      end
+    end
+  end
+end

data/lib/sprockets/sass/v4/functions.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+require_relative '../v3/functions'
+module Sprockets
+  module Sass
+    module V4
+      # Module used to inject helpers into SASS engine
+      module Functions
+        include Sprockets::Sass::V3::Functions
+      end
+    end
+  end
+end