sprockets-sass_embedded 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5f6b62daf25c2209dc30a139a96936334c2dd0716f9f167900a6437e1cf73f99
+  data.tar.gz: 88ac1cffbca937c8cd4b718601c341e18d075e1387efc818367e4c35997ecda9
+SHA512:
+  metadata.gz: b64eb2a10cd6632ed8dad9951da98913480e8cb590809a4dcbd382935caa74b3aa76dbc1e14f1fc2cd39a0b1222362367d068de3cddbf3ef000a57e4ad403b6a
+  data.tar.gz: 6b7bcd2e47436fd26a9c46a04242e7dc70b12727489e3748d357545fe7d430c198cc3f18e86034d3d39f9e50acdff0fbb1afcd506be474fd1c3b8f2e3e901205

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Jason Garber
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,109 @@
+# sprockets-sass_embedded
+
+[![Gem](https://img.shields.io/gem/v/sprockets-sass_embedded.svg?logo=rubygems&style=for-the-badge)](https://rubygems.org/gems/sprockets-sass_embedded)
+[![Downloads](https://img.shields.io/gem/dt/sprockets-sass_embedded.svg?logo=rubygems&style=for-the-badge)](https://rubygems.org/gems/sprockets-sass_embedded)
+[![Build](https://img.shields.io/github/workflow/status/jgarber623/sprockets-sass_embedded/CI?logo=github&style=for-the-badge)](https://github.com/jgarber623/sprockets-sass_embedded/actions/workflows/ci.yml)
+[![Maintainability](https://img.shields.io/codeclimate/maintainability/jgarber623/sprockets-sass_embedded.svg?logo=code-climate&style=for-the-badge)](https://codeclimate.com/github/jgarber623/sprockets-sass_embedded)
+[![Coverage](https://img.shields.io/codeclimate/c/jgarber623/sprockets-sass_embedded.svg?logo=code-climate&style=for-the-badge)](https://codeclimate.com/github/jgarber623/sprockets-sass_embedded/code)
+
+**A Ruby gem for processing and compressing [Sass](https://sass-lang.com) files using [Sprockets 4](https://github.com/rails/sprockets) and [Embedded Dart Sass](https://github.com/ntkme/sass-embedded-host-ruby).**
+
+## Installation
+
+Before installing and using sprockets-sass_embedded, you'll want to have [Ruby](https://www.ruby-lang.org) 2.7 (or newer) installed. If you're using [Bundler](https://bundler.io) to manage gem dependencies, add sprockets-sass_embedded to your project's Gemfile:
+
+```ruby
+gem 'sprockets-sass_embedded'
+```
+
+…and run `bundle install` in your shell.
+
+To install the gem manually, run the following in your shell:
+
+```sh
+gem install sprockets-sass_embedded
+```
+
+## Usage
+
+sprockets-sass_embedded works with projects leveraging Sprockets 4 for asset processing. With minimal configuration changes, [Ruby on Rails](https://rubyonrails.org), [Sinatra](https://sinatrarb.com), and [Roda](http://roda.jeremyevans.net) applications can take advantage of the features in recent versions of Dart Sass. sprockets-sass_embedded uses [Natsuki](https://github.com/ntkme)'s [sass-embedded](https://github.com/ntkme/sass-embedded-host-ruby) gem whose platform-specific releases closely track (and match version-for-version) the official [dart-sass](https://github.com/sass/dart-sass) project's releases.
+
+The examples below assume a Sass file named `application.scss` located in the assets path (e.g. `app/assets/stylesheets/application.scss`) appropriate for your app's framework. Asset paths are highly configurable, so the location of your asset files may vary.
+
+### Ruby on Rails
+
+With sprockets-sass_embedded added to your project's Gemfile and installed, set `config.assets.css_compressor = :sass_embedded` in your application's environment configuration. See the [Configuring Assets](https://guides.rubyonrails.org/configuring.html#configuring-assets) guide for additional details.
+
+### Sinatra
+
+In Sinatra applications, sprockets-sass_embedded can work in conjunction with the [sinatra-asset-pipeline](https://rubygems.org/gems/sinatra-asset-pipeline) gem. Using [sinatra-asset-pipeline's defaults](https://github.com/kalasjocke/sinatra-asset-pipeline/blob/master/lib/sinatra/asset_pipeline.rb#L7-L18), a sample `app.rb` file may look like:
+
+```ruby
+class App < Sinatra::Base
+  set :assets_precompile, %w(application.css)
+
+  set :assets_css_compressor, :sass_embedded
+
+  register Sinatra::AssetPipeline
+
+  get '/' do
+    'Hello, world!'
+  end
+end
+```
+
+### Roda
+
+Similar to Sinatra, Roda applications may be configured to use sprockets-sass_embedded alongside the [roda-sprockets](https://rubygems.org/gems/roda-sprockets) gem. A sample `config.ru` file might look like:
+
+```ruby
+class App < Roda
+  plugin :render
+
+  plugin :sprockets,
+         css_compressor: :sass_embedded,
+         debug: false,
+         precompile: %w[application.css]
+
+  route do |r|
+    r.sprockets unless opts[:environment] == 'production'
+
+    r.root do
+      render :index
+    end
+  end
+end
+
+run App.freeze.app
+```
+
+## Asset Helpers
+
+sprockets-sass-embedded includes a number of familiar helpers (e.g. `image_path`, `image_url`, `font_path`, `font_url`) that generate asset paths for use in your application. See [the `Functions` module](https://github.com/jgarber623/sprockets-sass_embedded/blob/main/lib/sprockets/sass_embedded/sass_processor.rb#L144-L318) in `lib/sprockets/sass_embedded/sass_processor.rb` for the available helpers.
+
+```scss
+@font-face {
+  font-family: "Hot Rush";
+  src: font_url("hot-rush.woff2") format("woff2"),
+       font_url("hot-rush.woff") format("woff");
+}
+
+html {
+  background: image_url("vaporwave.png") repeat 50% 50%;
+  font-family: "Times New Roman"
+}
+
+h1 {
+  font-family: "Hot Rush";
+}
+```
+
+## Acknowledgments
+
+sprockets-sass_embedded implements [Natsuki](https://github.com/ntkme)'s work from [rails/sprockets#737](https://github.com/rails/sprockets/pull/737) and wouldn't exist if not for their work bringing Dart Sass to Sprockets-enabled Ruby projects. Sprockets' internal workings are _fairly_ complicated, so the [Extending Sprockets guide](https://github.com/rails/sprockets/blob/main/guides/extending_sprockets.md) was also helpful.
+
+sprockets-sass_embedded is written and maintained by [Jason Garber](https://sixtwothree.org).
+
+## License
+
+sprockets-sass_embedded is freely available under the [MIT License](https://opensource.org/licenses/MIT). Use it, learn from it, fork it, improve it, change it, tailor it to your needs.

data/lib/sprockets/sass_embedded/sass_compressor.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Sprockets
+  module SassEmbedded
+    # Sass CSS minifier.
+    #
+    # @example Using the default options.
+    #
+    #   environment.register_bundle_processor 'text/css',
+    #     Sprockets::SassEmbedded::SassCompressor
+    #
+    # @example Passing options to the SassEmbedded compiler.
+    #
+    #   environment.register_bundle_processor 'text/css',
+    #     Sprockets::SassEmbedded::SassCompressor.new({ ... })
+    #
+    class SassCompressor
+      VERSION = '1'
+
+      private_constant :VERSION
+
+      # @return [String]
+      def self.cache_key
+        instance.cache_key
+      end
+
+      # @param input [Hash]
+      # @return [Hash{Symbol => String}]
+      def self.call(input)
+        instance.call(input)
+      end
+
+      # @return [Sprockets::SassEmbedded::SassCompressor]
+      def self.instance
+        @instance ||= new
+      end
+
+      # @param options [Hash]
+      def initialize(**options)
+        @options = {
+          source_map: true,
+          style: :compressed,
+          syntax: :css
+        }.merge(options).freeze
+      end
+
+      # @return [String]
+      def cache_key
+        @cache_key ||=
+          [
+            self.class.name,
+            Autoload::SassEmbedded::Embedded::VERSION,
+            VERSION,
+            DigestUtils.digest(@options)
+          ].join(':')
+      end
+
+      # @param input [Hash]
+      # @return [Hash{Symbol => String}]
+      def call(input)
+        result = Autoload::SassEmbedded.compile_string(
+          input[:data],
+          **@options.merge(url: URIUtils.build_asset_uri(input[:filename]))
+        )
+
+        css = result.css
+
+        map = SourceMapUtils.combine_source_maps(
+          input[:metadata][:map],
+          SourceMapUtils.format_source_map(JSON.parse(result.source_map), input)
+        )
+
+        { data: css, map: map }
+      end
+    end
+  end
+end

data/lib/sprockets/sass_embedded/sass_processor.rb

@@ -0,0 +1,323 @@
+# frozen_string_literal: true
+
+module Sprockets
+  module SassEmbedded
+    class SassProcessor
+      # @see https://sass-lang.com/documentation/js-api/interfaces/Options#functions
+      class DartSassFunctionsHash
+        # @param functions [Module]
+        # @param options [Hash{Symbol => Hash}]
+        def initialize(functions, options)
+          @functions = functions
+
+          instance.define_singleton_method(:options, -> { options })
+        end
+
+        # @return [Hash{String => Proc}]
+        def to_hash
+          @functions
+            .public_instance_methods
+            .each_with_object({}) do |symbol, obj|
+              parameters = instance.method(symbol)
+                                   .parameters
+                                   .filter_map { |parameter| "$#{parameter.last}" if parameter.first == :req }
+
+              obj["#{symbol}(#{parameters.join(', ')})"] = ->(args) { instance.send(symbol, *args) }
+            end
+        end
+
+        alias_method :to_h, :to_hash
+
+        private
+
+        def instance
+          @instance ||= Class.new.extend(@functions)
+        end
+      end
+
+      private_constant :DartSassFunctionsHash
+
+      VERSION = '1'
+
+      private_constant :VERSION
+
+      # @return [String]
+      def self.cache_key
+        instance.cache_key
+      end
+
+      def self.call(input)
+        instance.call(input)
+      end
+
+      # @return [Sprockets::SassEmbedded::SassProcessor]
+      def self.instance
+        @instance ||= new
+      end
+
+      # @return [Symbol]
+      def self.syntax
+        :indented
+      end
+
+      # Public: Initialize template with custom options.
+      #
+      # options - Hash
+      # cache_version - String custom cache version. Used to force a cache
+      #                 change after code changes are made to Sass Functions.
+      #
+      def initialize(cache_version: nil, functions: nil, sass_config: {}, **_options)
+        @cache_version = cache_version
+        @sass_config = sass_config
+
+        @functions = Module.new do
+          include Functions
+          include functions if functions
+          class_eval(&block) if block_given?
+        end
+      end
+
+      # @return [String]
+      def cache_key
+        @cache_key ||=
+          [
+            self.class.name,
+            VERSION,
+            Autoload::SassEmbedded::Embedded::VERSION,
+            @cache_version
+          ].join(':')
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def call(input)
+        context = input[:environment].context_class.new(input)
+
+        options = merge_options(
+          functions: DartSassFunctionsHash.new(
+            @functions,
+            sprockets: {
+              context: context,
+              dependencies: context.metadata[:dependencies],
+              environment: input[:environment]
+            }
+          ).to_h,
+          load_paths: context.environment.paths,
+          source_map: true,
+          syntax: self.class.syntax,
+          url: URIUtils.build_asset_uri(input[:filename])
+        )
+
+        result = Autoload::SassEmbedded.compile_string(input[:data], **options)
+
+        css = result.css
+
+        map = SourceMapUtils.combine_source_maps(
+          input[:metadata][:map],
+          SourceMapUtils.format_source_map(JSON.parse(result.source_map), input)
+        )
+
+        sass_dependencies = Set.new
+
+        result.loaded_urls.each do |url|
+          scheme, _host, path, _query = URIUtils.split_file_uri(url)
+
+          next unless scheme == 'file'
+
+          sass_dependencies << path
+          context.metadata[:dependencies] << URIUtils.build_file_digest_uri(path)
+        end
+
+        context.metadata.merge(data: css, map: map, sass_dependencies: sass_dependencies)
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      private
+
+      def merge_options(options)
+        defaults = @sass_config.dup
+
+        if (load_paths = defaults.delete(:load_paths))
+          options[:load_paths] += load_paths
+        end
+
+        options.merge!(defaults)
+      end
+
+      # Functions injected into Sass context during Sprockets evaluation.
+      #
+      # This module may be extended to add global functionality to all Sprockets
+      # Sass environments. Scoping your functions to just your environment is
+      # preferred.
+      #
+      # @example
+      #
+      #   module Sprockets::SassProcessor::Functions
+      #     def asset_path(path, options = {})
+      #     end
+      #   end
+      #
+      module Functions
+        # Generate a URL for asset path.
+        #
+        # @param path [Sass::Script::String]
+        # @param options [Hash]
+        # @return [SassEmbedded::Value::String]
+        def asset_path(path, **options)
+          path = path.text
+
+          path, _, query, fragment = URI.split(path)[5..8]
+          path     = sprockets_context.asset_path(path, options)
+          query    = "?#{query}" if query
+          fragment = "##{fragment}" if fragment
+
+          Autoload::SassEmbedded::Value::String.new("#{path}#{query}#{fragment}", quoted: true)
+        end
+
+        # Generate an asset +url()+ link.
+        #
+        # @param path [Sass::Script::String]
+        # @return [SassEmbedded::Value::String]
+        def asset_url(path, **options)
+          Autoload::SassEmbedded::Value::String.new("url(#{asset_path(path, options).text})", quoted: false)
+        end
+
+        # Generate a URL for image path.
+        #
+        # @param path [Sass::Script::String]
+        # @return [SassEmbedded::Value::String]
+        def image_path(path)
+          asset_path(path, type: :image)
+        end
+
+        # Generate an image +url()+ link.
+        #
+        # @param path [Sass::Script::String]
+        # @return [SassEmbedded::Value::String]
+        def image_url(path)
+          asset_url(path, type: :image)
+        end
+
+        # Generate a URL for video path.
+        #
+        # @param path [Sass::Script::String]
+        # @return [SassEmbedded::Value::String]
+        def video_path(path)
+          asset_path(path, type: :video)
+        end
+
+        # Generate a video +url()+ link.
+        #
+        # @param path [Sass::Script::String]
+        # @return [SassEmbedded::Value::String]
+        def video_url(path)
+          asset_url(path, type: :video)
+        end
+
+        # Generate a URL for audio path.
+        #
+        # @param path [Sass::Script::String]
+        # @return [SassEmbedded::Value::String]
+        def audio_path(path)
+          asset_path(path, type: :audio)
+        end
+
+        # Generate an audio +url()+ link.
+        #
+        # @param path [Sass::Script::String]
+        # @return [SassEmbedded::Value::String]
+        def audio_url(path)
+          asset_url(path, type: :audio)
+        end
+
+        # Generate a URL for font path.
+        #
+        # @param path [Sass::Script::String]
+        # @return [SassEmbedded::Value::String]
+        def font_path(path)
+          asset_path(path, type: :font)
+        end
+
+        # Generate a font +url()+ link.
+        #
+        # @param path [Sass::Script::String]
+        # @return [SassEmbedded::Value::String]
+        def font_url(path)
+          asset_url(path, type: :font)
+        end
+
+        # Generate a URL for JavaScript path.
+        #
+        # @param path [Sass::Script::String]
+        # @return [SassEmbedded::Value::String]
+        def javascript_path(path)
+          asset_path(path, type: :javascript)
+        end
+
+        # Generate a JavaScript +url()+ link.
+        #
+        # @param path [Sass::Script::String]
+        # @return [SassEmbedded::Value::String]
+        def javascript_url(path)
+          asset_url(path, type: :javascript)
+        end
+
+        # Generate a URL for stylesheet path.
+        #
+        # @param path [Sass::Script::String]
+        # @return [SassEmbedded::Value::String]
+        def stylesheet_path(path)
+          asset_path(path, type: :stylesheet)
+        end
+
+        # Generate a stylesheet +url()+ link.
+        #
+        # @param path [Sass::Script::String]
+        # @return [SassEmbedded::Value::String]
+        def stylesheet_url(path)
+          asset_url(path, type: :stylesheet)
+        end
+
+        # Generate a +data:+ URI for asset path.
+        #
+        # @param path [Sass::Script::String]
+        # @return [SassEmbedded::Value::String]
+        def asset_data_uri(path)
+          url = sprockets_context.asset_data_uri(path.text)
+          Autoload::SassEmbedded::Value::String.new(url)
+        end
+
+        # Genearte a +data:+ +url()+ link.
+        #
+        # @param path [Sass::Script::String]
+        # @return [SassEmbedded::Value::String]
+        def asset_data_url(path)
+          Autoload::SassEmbedded::Value::String.new("url(#{asset_data_uri(path)})", quoted: false)
+        end
+
+        protected
+
+        # @deprecated Use #sprockets_environment or #sprockets_dependencies
+        # instead.
+        #
+        # @return [Sprockets::Context]
+        def sprockets_context
+          options[:sprockets][:context]
+        end
+
+        # A mutatable set of dependencies.
+        #
+        # @return [Set]
+        def sprockets_dependencies
+          options[:sprockets][:dependencies]
+        end
+
+        # The Environment.
+        #
+        # @return [Sprockets::Environment]
+        def sprockets_environment
+          options[:sprockets][:environment]
+        end
+      end
+    end
+  end
+end

data/lib/sprockets/sass_embedded/scss_processor.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Sprockets
+  module SassEmbedded
+    class ScssProcessor < SassProcessor
+      # @return [Symbol]
+      def self.syntax
+        :scss
+      end
+    end
+  end
+end

data/lib/sprockets/sass_embedded/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sprockets
+  module SassEmbedded
+    VERSION = '0.1.0'
+  end
+end

data/lib/sprockets/sass_embedded.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'sass-embedded'
+require 'sprockets'
+
+require_relative 'sass_embedded/sass_compressor'
+require_relative 'sass_embedded/sass_processor'
+require_relative 'sass_embedded/scss_processor'
+
+module Sprockets
+  module Autoload
+    SassEmbedded = ::Sass
+  end
+
+  register_transformer 'text/sass', 'text/css', SassEmbedded::SassProcessor
+  register_transformer 'text/scss', 'text/css', SassEmbedded::ScssProcessor
+
+  register_compressor 'text/css', :sass_embedded, SassEmbedded::SassCompressor
+end

data/sprockets-sass_embedded.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'lib/sprockets/sass_embedded/version'
+
+Gem::Specification.new do |spec|
+  spec.required_ruby_version = '>= 2.7', '< 4'
+
+  spec.name          = 'sprockets-sass_embedded'
+  spec.version       = Sprockets::SassEmbedded::VERSION
+  spec.authors       = ['Jason Garber']
+  spec.email         = ['jason@sixtwothree.org']
+
+  spec.summary       = 'Process and compress Sass files using Sprockets 4 and Embedded Dart Sass.'
+  spec.description   = spec.summary
+  spec.homepage      = 'https://github.com/jgarber623/sprockets-sass_embedded'
+  spec.license       = 'MIT'
+
+  spec.files         = Dir['lib/**/*'].reject { |f| File.directory?(f) }
+  spec.files        += %w[LICENSE README.md]
+  spec.files        += %w[sprockets-sass_embedded.gemspec]
+
+  spec.require_paths = ['lib']
+
+  spec.metadata = {
+    'bug_tracker_uri'       => "#{spec.homepage}/issues",
+    'changelog_uri'         => "#{spec.homepage}/blob/v#{spec.version}/CHANGELOG.md",
+    'rubygems_mfa_required' => 'true'
+  }
+
+  spec.add_runtime_dependency 'sass-embedded', '>= 1.54.6'
+  spec.add_runtime_dependency 'sprockets', '~> 4.0'
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: sprockets-sass_embedded
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jason Garber
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-09-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sass-embedded
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.54.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.54.6
+- !ruby/object:Gem::Dependency
+  name: sprockets
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: Process and compress Sass files using Sprockets 4 and Embedded Dart Sass.
+email:
+- jason@sixtwothree.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/sprockets/sass_embedded.rb
+- lib/sprockets/sass_embedded/sass_compressor.rb
+- lib/sprockets/sass_embedded/sass_processor.rb
+- lib/sprockets/sass_embedded/scss_processor.rb
+- lib/sprockets/sass_embedded/version.rb
+- sprockets-sass_embedded.gemspec
+homepage: https://github.com/jgarber623/sprockets-sass_embedded
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/jgarber623/sprockets-sass_embedded/issues
+  changelog_uri: https://github.com/jgarber623/sprockets-sass_embedded/blob/v0.1.0/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: '4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.16
+signing_key: 
+specification_version: 4
+summary: Process and compress Sass files using Sprockets 4 and Embedded Dart Sass.
+test_files: []