sprockets-sass 1.3.1 → 2.0.0.beta1

data/lib/sprockets/sass/functions.rb

@@ -1,163 +1,28 @@
-require 'sass'
-
-module Sprockets
-  module Sass
+# frozen_string_literal: true
+module Sass
+  module Script
+    # Original Sass script functions are overidden with this methods
     module Functions
-      # Using Sprockets::Context#asset_data_uri return a Base64-encoded `data:`
-      # URI with the contents of the asset at the specified path.
-      #
-      # === Examples
-      #
-      #   background: asset-data-uri("image.jpg"); // background: url(data:image/jpeg;base64,...);
-      #
-      def asset_data_uri(source)
-        ::Sass::Script::String.new "url(#{sprockets_context.asset_data_uri(source.value)})"
-      end
-
-      # Using Sprockets::Helpers#asset_path, return the full path
-      # for the given +source+ as a Sass String. This supports keyword
-      # arguments that mirror the +options+.
-      #
-      # === Examples
-      #
-      #   background: url(asset-path("image.jpg"));                // background: url("/assets/image.jpg");
-      #   background: url(asset-path("image.jpg", $digest: true)); // background: url("/assets/image-27a8f1f96afd8d4c67a59eb9447f45bd.jpg");
-      #
-      def asset_path(source, options = {})
-        # Work with the Sass::Rails #asset_path API
-        if options.respond_to? :value
-          kind = options.value
-          options = {}
-        end
-
-        if kind && sprockets_context.respond_to?("#{kind}_path")
-          ::Sass::Script::String.new sprockets_context.send("#{kind}_path", source.value), :string
-        else
-          ::Sass::Script::String.new sprockets_context.asset_path(source.value, map_options(options)).to_s, :string
-        end
-      end
-
-      # Using Sprockets::Helpers#asset_path, return the url CSS
-      # for the given +source+ as a Sass String. This supports keyword
-      # arguments that mirror the +options+.
-      #
-      # === Examples
-      #
-      #   background: asset-url("image.jpg");                // background: url("/assets/image.jpg");
-      #   background: asset-url("image.jpg", $digest: true); // background: url("/assets/image-27a8f1f96afd8d4c67a59eb9447f45bd.jpg");
-      #
-      def asset_url(source, options = {})
-        ::Sass::Script::String.new "url(#{asset_path(source, options)})"
-      end
-
-      # Using Sprockets::Helpers#image_path, return the full path
-      # for the given +source+ as a Sass String. This supports keyword
-      # arguments that mirror the +options+.
-      #
-      # === Examples
-      #
-      #   background: url(image-path("image.jpg"));                // background: url("/assets/image.jpg");
-      #   background: url(image-path("image.jpg", $digest: true)); // background: url("/assets/image-27a8f1f96afd8d4c67a59eb9447f45bd.jpg");
-      #
-      def image_path(source, options = {})
-        ::Sass::Script::String.new sprockets_context.image_path(source.value, map_options(options)).to_s, :string
-      end
-
-      # Using Sprockets::Helpers#image_path, return the url CSS
-      # for the given +source+ as a Sass String. This supports keyword
-      # arguments that mirror the +options+.
-      #
-      # === Examples
-      #
-      #   background: image-url("image.jpg");                // background: url("/assets/image.jpg");
-      #   background: image-url("image.jpg", $digest: true); // background: url("/assets/image-27a8f1f96afd8d4c67a59eb9447f45bd.jpg");
-      #
-      def image_url(source, options = {}, cache_buster = nil)
-        # Work with the Compass #image_url API
-        if options.respond_to? :value
-          case options.value
-          when true
-            return image_path source
-          else
-            options = {}
-          end
-        end
-        ::Sass::Script::String.new "url(#{image_path(source, options)})"
-      end
-
-      # Using Sprockets::Helpers#font_path, return the full path
-      # for the given +source+ as a Sass String. This supports keyword
-      # arguments that mirror the +options+.
-      #
-      # === Examples
-      #
-      #   src: url(font-path("font.ttf"));                // src: url("/assets/font.ttf");
-      #   src: url(font-path("font.ttf", $digest: true)); // src: url("/assets/font-27a8f1f96afd8d4c67a59eb9447f45bd.ttf");
-      #
-      def font_path(source, options = {})
-        ::Sass::Script::String.new sprockets_context.font_path(source.value, map_options(options)).to_s, :string
-      end
-
-      # Using Sprockets::Helpers#font_path, return the url CSS
-      # for the given +source+ as a Sass String. This supports keyword
-      # arguments that mirror the +options+.
-      #
-      # === Examples
-      #
-      #   src: font-url("font.ttf");                  // src: url("/assets/font.ttf");
-      #   src: font-url("image.jpg", $digest: true);  // src: url("/assets/font-27a8f1f96afd8d4c67a59eb9447f45bd.ttf");
-      #
-      def font_url(source, options = {})
-        # Work with the Compass #font_url API
-        if options.respond_to? :value
-          case options.value
-          when true
-            return font_path source
-          else
-            options = {}
-          end
-        end
-        ::Sass::Script::String.new "url(#{font_path(source, options)})"
-      end
-
-      protected
-
-      # Returns a reference to the Sprocket's context through
-      # the importer.
-      def sprockets_context # :nodoc:
-        options[:custom][:sprockets_context]
-      end
-
-      # Returns an options hash where the keys are symbolized
-      # and the values are unwrapped Sass literals.
-      def map_options(options = {}) # :nodoc:
-        ::Sass::Util.map_hash(options) do |key, value|
-          [key.to_sym, value.respond_to?(:value) ? value.value : value]
-        end
-      end
+      include Sprockets::Sass::Utils.get_class_by_version('Functions')
+
+      # Hack to ensure previous API declarations (by Compass or whatever)
+      # don't take precedence.
+      %i(asset_path asset_url image_path image_url font_path font_url asset_data_uri).each do |method|
+        defined?(@signatures) && @signatures.delete(method)
+      end
+
+      declare :asset_path,     [:source], var_kwargs: true
+      declare :asset_path,     %i(source kind)
+      declare :asset_url,      [:source], var_kwargs: true
+      declare :asset_url,      %i(source kind)
+      declare :image_path,     [:source], var_kwargs: true
+      declare :image_url,      [:source], var_kwargs: true
+      declare :image_url,      %i(source only_path)
+      declare :image_url,      %i(source only_path cache_buster)
+      declare :font_path,      [:source], var_kwargs: true
+      declare :font_url,       [:source], var_kwargs: true
+      declare :font_url,       %i(source only_path)
+      declare :asset_data_uri, [:source]
     end
   end
 end
-
-module Sass::Script::Functions
-  include Sprockets::Sass::Functions
-
-  # Hack to ensure previous API declarations (by Compass or whatever)
-  # don't take precedence.
-  [:asset_path, :asset_url, :image_path, :image_url, :font_path, :font_url, :asset_data_uri].each do |method|
-    defined?(@signatures) && @signatures.delete(method)
-  end
-
-  declare :asset_path,     [:source], :var_kwargs => true
-  declare :asset_path,     [:source, :kind]
-  declare :asset_url,      [:source], :var_kwargs => true
-  declare :asset_url,      [:source, :kind]
-  declare :image_path,     [:source], :var_kwargs => true
-  declare :image_url,      [:source], :var_kwargs => true
-  declare :image_url,      [:source, :only_path]
-  declare :image_url,      [:source, :only_path, :cache_buster]
-  declare :font_path,      [:source], :var_kwargs => true
-  declare :font_url,       [:source], :var_kwargs => true
-  declare :font_url,       [:source, :only_path]
-  declare :asset_data_uri, [:source]
-end

data/lib/sprockets/sass/registration.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+module Sprockets
+  module Sass
+    # class useful for registering engines, tranformers, preprocessors and conpressors for sprockets
+    # depending on the version of sprockets
+    class Registration
+      attr_reader :klass, :sprockets_version, :registration_instance
+
+      def initialize(klass)
+        @klass = klass
+        @sprockets_version = Sprockets::Sass::Utils.version_of_sprockets
+        @registration_instance = self
+      end
+
+      def run
+        require_libraries
+        case @sprockets_version
+          when 2...3
+            register_sprockets_legacy
+          when 3...4
+            register_sprockets_v3
+          when 4...5
+            register_sprockets_v4
+          else
+            raise "Version #{Sprockets::Sass::Utils.full_version_of_sprockets} is not supported"
+        end
+      end
+
+      def require_libraries
+        require_standard_libraries
+        require 'sprockets/sass/functions'
+      end
+
+    private
+
+      def require_standard_libraries(version = @sprockets_version)
+        %w(cache_store compressor functions importer sass_template scss_template).each do |filename|
+          begin
+            require "sprockets/sass/v#{version}/#{filename}"
+          rescue LoadError; end
+        end
+      end
+
+      def register_sprockets_v3_common
+        %w(sass scss).each do |mime|
+          _register_mime_types(mime_type:  "application/#{mime}+ruby", extensions: [".#{mime}.erb", ".css.#{mime}.erb"])
+        end
+        _register_compressors(mime_type: 'text/css', name: :sprockets_sass, klass: Sprockets::Sass::Utils.get_class_by_version('Compressor'))
+      end
+
+      def register_sprockets_v4
+        register_sprockets_v3_common
+        %w(sass scss).each do |mime|
+          _register_mime_types(mime_type:  "text/#{mime}", extensions: [".#{mime}", ".css.#{mime}"])
+        end
+        %w(sass scss).each do |mime|
+          _register_transformers(from: "application/#{mime}+ruby", to: "text/#{mime}", klass: Sprockets::ERBProcessor)
+        end
+        _register_v4_preprocessors(
+          Sprockets::Sass::V4::SassTemplate => ['text/sass'],
+          Sprockets::Sass::V4::ScssTemplate => ['text/scss']
+        )
+        _register_transformers(
+          { from: 'text/sass', to: 'text/css', klass: Sprockets::Sass::V4::SassTemplate },
+          from: 'text/scss', to: 'text/css', klass: Sprockets::Sass::V4::ScssTemplate
+        )
+      end
+
+      def register_sprockets_v3
+        register_sprockets_v3_common
+        _register_transformers(
+          { from: 'application/scss+ruby', to: 'text/css', klass: Sprockets::ERBProcessor },
+          from: 'application/sass+ruby', to: 'text/css', klass: Sprockets::ERBProcessor
+        )
+        _register_engines('.sass' => Sprockets::Sass::V3::SassTemplate, '.scss' => Sprockets::Sass::V3::ScssTemplate)
+      end
+
+      def register_sprockets_legacy
+        _register_engines('.sass' => Sprockets::Sass::V2::SassTemplate, '.scss' => Sprockets::Sass::V2::ScssTemplate)
+      end
+
+      def _register_engines(hash)
+        hash.each do |key, value|
+          args = [key, value]
+          args << { mime_type: 'text/css', silence_deprecation: true } if sprockets_version >= 3
+          register_engine(*args)
+        end
+      end
+
+      def _register_mime_types(*mime_types)
+        mime_types.each do |mime_data|
+          register_mime_type(mime_data[:mime_type], extensions: mime_data[:extensions])
+        end
+      end
+
+      def _register_compressors(*compressors)
+        compressors.each do |compressor|
+          register_compressor(compressor[:mime_type], compressor[:name], compressor[:klass])
+        end
+      end
+
+      def _register_transformers(*tranformers)
+        tranformers.each do |tranformer|
+          register_transformer(tranformer[:from], tranformer[:to], tranformer[:klass])
+        end
+      end
+
+      def _register_v4_preprocessors(hash)
+        hash.each do |key, value|
+          value.each do |mime|
+            register_preprocessor(mime, key)
+          end
+        end
+      end
+
+      def method_missing(sym, *args, &block)
+        @klass.public_send(sym, *args, &block) || super
+      end
+
+      def respond_to_missing?(method_name, include_private = nil)
+        include_private = include_private.blank? ? true : include_private
+        @klass.public_methods.include?(method_name) || super(method_name, include_private)
+      end
+    end
+  end
+end

data/lib/sprockets/sass/utils.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+module Sprockets
+  module Sass
+    # utility functions that can be used statically from anywhere
+    class Utils
+      class << self
+        def full_version_of_sprockets
+          Sprockets::VERSION
+        end
+
+        def version_of_sprockets
+          full_version_of_sprockets.split('.')[0].to_i
+        end
+
+        def read_file_binary(file, options = {})
+          default_encoding = options.delete :default_encoding
+
+          # load template data and prepare (uses binread to avoid encoding issues)
+          data = read_template_file(file)
+
+          if data.respond_to?(:force_encoding)
+            if default_encoding
+              data = data.dup if data.frozen?
+              data.force_encoding(default_encoding)
+            end
+
+            unless data.valid_encoding?
+              raise Encoding::InvalidByteSequenceError, "#{filename} is not valid #{data.encoding}"
+            end
+          end
+          data
+        end
+
+        def digest(options)
+          options.delete_if { |_key, value| value.is_a?(Pathname) } if options.is_a?(Hash)
+          options = options.to_s unless options.is_a?(Hash)
+          if defined?(Sprockets::DigestUtils)
+            Sprockets::DigestUtils.digest(options)
+          else
+            options = options.is_a?(Hash) ? options : { value: options }
+            Digest::SHA256.hexdigest(JSON.generate(options))
+          end
+        end
+
+        def read_template_file(file)
+          data = File.open(file, 'rb', &:read)
+          if data.respond_to?(:force_encoding)
+            # Set it to the default external (without verifying)
+            data.force_encoding(Encoding.default_external) if Encoding.default_external
+          end
+          data
+        end
+
+        def get_class_by_version(class_name, version = version_of_sprockets)
+          constantize("Sprockets::Sass::V#{version}::#{class_name}")
+        rescue
+          nil
+        end
+
+        def constantize(camel_cased_word)
+          names = camel_cased_word.split('::')
+
+          # Trigger a built-in NameError exception including the ill-formed constant in the message.
+          Object.const_get(camel_cased_word) if names.empty?
+
+          # Remove the first blank element in case of '::ClassName' notation.
+          names.shift if names.size > 1 && names.first.empty?
+
+          names.reduce(Object) do |constant, name|
+            if constant == Object
+              constant.const_get(name)
+            else
+              candidate = constant.const_get(name)
+              next candidate if constant.const_defined?(name, false)
+              next candidate unless Object.const_defined?(name)
+
+              # Go down the ancestors to check if it is owned directly. The check
+              # stops when we reach Object or the end of ancestors tree.
+              constant = constant.ancestors.each_with_object do |ancestor, const|
+                break const    if ancestor == Object
+                break ancestor if ancestor.const_defined?(name, false)
+                const
+              end
+
+              # owner is in Object, so raise
+              constant.const_get(name, false)
+            end
+          end
+        end
+
+        def module_include(base, mod)
+          old_methods = {}
+
+          mod.instance_methods.each do |sym|
+            old_methods[sym] = base.instance_method(sym) if base.method_defined?(sym)
+          end
+
+          mod.instance_methods.each do |sym|
+            method = mod.instance_method(sym)
+            base.send(:define_method, sym, method)
+          end
+
+          yield
+        ensure
+          mod.instance_methods.each do |sym|
+            base.send(:undef_method, sym) if base.method_defined?(sym)
+          end
+          old_methods.each do |sym, method|
+            base.send(:define_method, sym, method)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module Sprockets
+  module Sass
+    module V2
+      # Internal: Cache wrapper for Sprockets cache adapter. (Sprockets 2.x)
+      class CacheStore < ::Sass::CacheStores::Base
+        attr_reader :environment
+
+        def initialize(environment)
+          @environment = environment
+        end
+
+        def _store(key, version, sha, contents)
+          environment.send :cache_set, "sass/#{key}", version: version, sha: sha, contents: contents
+        end
+
+        def _retrieve(key, version, sha)
+          obj = environment.send(:cache_get, "sass/#{key}")
+          return unless obj.is_a?(Hash)
+          return if obj[:version] != version || obj[:sha] != sha
+          obj[:obj]
+        end
+      end
+    end
+  end
+end