sasso-rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ec674d60203b29114c080883f7e4cf438fa36dbc8b43daaebb02f7d197ffbf2e
+  data.tar.gz: cd677fde1997dae468d8ad8acdd4de81a41847931ba6f72a9d7b102cfe523bbe
+SHA512:
+  metadata.gz: ca83ee104decbe95b065399c956584959c4f8599658c590c90c371859a920562f611eb7d41171d53e1581a3d66160ccb5bd02fd2545986ad87c9fba975075079
+  data.tar.gz: 9df668f046ac42666b9ab9e65aba3b0b29fe3dfb0d018ccf8f7afc821f8f4378e76afbf0b5ca151ac6efc9b987a52160f0279fdcfeaa55215e3bb3738c39347c

data/CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+All notable changes to the **sasso-rails** gem are documented here.
+The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+
+This gem versions independently of the `sasso` compiler gem; each release notes
+the engine-gem version range it requires.
+
+## [Unreleased]
+
+## [0.1.0] - 2026-06-13
+
+Initial release. Requires the `sasso` gem **>= 0.1.1, < 1**.
+
+### Added
+
+- `Sasso::Rails::Engine` — wires sasso into a Rails app with `config.sasso.*`
+  (`builds`, `style`, `load_paths`, `source_dir`, `build_dir`).
+- Rake tasks `sasso:build`, `sasso:watch`, and `sasso:clobber`; `sasso:build`
+  is enhanced onto `assets:precompile` (and `sasso:clobber` onto
+  `assets:clobber`).
+- `Sasso::Rails::Compiler` — Rails-free build object; compiles each entrypoint
+  with the in-process `Sasso.compile` (no subprocess / Node.js) and writes to
+  `app/assets/builds`.
+- `bin/rails sasso:install` generator: scaffolds `application.scss`, the builds
+  directory, a Sprockets manifest link (when present), and a `Procfile.dev`
+  watch process.
+- Propshaft-first, Sprockets-compatible (compiled CSS is served as a static
+  build artifact by either pipeline).

data/LICENSE-MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 linyiru
+
+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,115 @@
+# sasso-rails
+
+Rails integration for [**sasso**](https://github.com/momiji-rs/sasso-ruby) — a
+pure-Rust, zero-dependency SCSS/Sass → CSS compiler (a byte-for-byte dart-sass
+alternative).
+
+Compiles your stylesheets into `app/assets/builds/` for the Rails asset
+pipeline to serve. **Propshaft-first** (the Rails 8 default) and
+Sprockets-compatible.
+
+Why this gem over the alternatives:
+
+- **No Node.js.** Unlike `cssbundling-rails`, there is no `node`/`yarn`/`npx`
+  requirement — the compiler ships as a precompiled Ruby native gem.
+- **In-process, no subprocess.** Unlike `dartsass-rails` / `tailwindcss-rails`
+  (which shell out to a standalone binary), sasso-rails calls `Sasso.compile`
+  directly through the native extension — no process spawn, no IPC.
+- **Pure Rust core.** No libsass (deprecated), no Dart VM.
+
+## Installation
+
+```ruby
+# Gemfile
+gem "sasso-rails"
+```
+
+```sh
+bundle install
+bin/rails generate sasso:install
+```
+
+The installer scaffolds `app/assets/stylesheets/application.scss`, creates
+`app/assets/builds/` (with a `.keep`), links the builds directory in a Sprockets
+manifest if one exists, and adds a watch process to `Procfile.dev`.
+
+Reference the compiled CSS in your layout:
+
+```erb
+<%= stylesheet_link_tag "application" %>
+```
+
+## Usage
+
+```sh
+bin/rails sasso:build     # compile once
+bin/rails sasso:watch     # recompile on change (or run ./bin/dev)
+bin/rails sasso:clobber   # remove generated CSS
+```
+
+`sasso:build` runs automatically before `assets:precompile`, so deploys
+(`rails assets:precompile`) regenerate the CSS before the pipeline fingerprints
+it. No extra deploy wiring needed.
+
+## Configuration
+
+In `config/application.rb` (or an environment file):
+
+```ruby
+# Map each entrypoint (under source_dir) to an output file (under build_dir).
+config.sasso.builds = {
+  "application.scss" => "application.css",
+  "admin.scss"       => "admin.css",
+}
+
+# :expanded | :compressed. Default: :compressed in production, :expanded else.
+config.sasso.style = :compressed
+
+# Extra @use/@import include dirs. The entrypoint's own directory is always
+# searched first, so sibling partials need no configuration.
+config.sasso.load_paths = [Rails.root.join("vendor/styles").to_s]
+
+# Defaults shown:
+config.sasso.source_dir = "app/assets/stylesheets"
+config.sasso.build_dir  = "app/assets/builds"
+```
+
+## How it fits the pipeline
+
+`sasso:build` writes plain CSS to `app/assets/builds/`. Both pipelines treat
+that directory as a source of ready-to-serve assets:
+
+- **Propshaft** (Rails 8 default) discovers `app/assets/builds` on its load
+  path, fingerprints the CSS, and rewrites `url(...)` references — it performs
+  no Sass compilation itself.
+- **Sprockets** serves the built CSS as a static asset (the installer adds
+  `//= link_tree ../builds` to `app/assets/config/manifest.js`).
+
+## Notes & limitations
+
+- **Source maps are not supported yet.** The in-process compiler returns CSS
+  only; there is no `.css.map` output in any environment.
+- **`builds` is file-to-file.** Each entry maps one input file to one output
+  file. There is no directory-glob form (no `"." => "."`); list each entrypoint
+  explicitly.
+- **Load paths are explicit.** Only the entrypoint's own directory (searched
+  automatically) and `config.sasso.load_paths` are on the `@use`/`@import`
+  search path. Gem-vendored or `config.assets.paths` stylesheets are NOT added
+  automatically — list their directories in `config.sasso.load_paths`.
+- **No double-minification.** On a Sprockets app that sets
+  `config.assets.css_compressor`, sasso-rails stays `:expanded` and lets the
+  pipeline compress (unless you pin `config.sasso.style`). Propshaft does not
+  compress, so production output is `:compressed` there.
+- **Watch is a 1s mtime poll** (dependency-free, no native fs-events); it covers
+  the source dir and `config.sasso.load_paths`.
+
+## Versioning
+
+This gem versions independently of the `sasso` compiler gem and pins it with a
+range (`sasso >= 0.1.1, < 1`). An app may pin a specific compiler version in its
+own `Gemfile`.
+
+## License
+
+MIT, matching the Sass ecosystem. (The core `sasso` compiler crate remains
+dual-licensed MIT OR Apache-2.0.)

data/lib/generators/sasso/install/install_generator.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require "rails/generators/base"
+
+module Sasso
+  module Generators
+    # `bin/rails sasso:install` — scaffolds the entrypoint + build dir and wires
+    # a dev watch process, mirroring the dartsass/tailwindcss install flow.
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      def create_stylesheet
+        template "application.scss", "app/assets/stylesheets/application.scss"
+      end
+
+      def ensure_builds_directory
+        create_file "app/assets/builds/.keep" unless File.exist?(builds_keep_path)
+
+        rules = "/app/assets/builds/*\n!/app/assets/builds/.keep\n"
+        if File.exist?(gitignore_path)
+          # Idempotent: skip if already present (re-running the installer).
+          append_to_file ".gitignore", rules unless File.read(gitignore_path).include?("/app/assets/builds/")
+        else
+          # No .gitignore at all — create one so generated CSS isn't committed.
+          create_file ".gitignore", rules
+        end
+      end
+
+      # Sprockets-only apps must link the builds directory in the manifest;
+      # Propshaft discovers it automatically, so guard on the manifest existing.
+      def link_builds_in_sprockets_manifest
+        manifest = "app/assets/config/manifest.js"
+        full = File.join(destination_root, manifest)
+        return unless File.exist?(full)
+        return if File.read(full).include?("link_tree ../builds")
+
+        append_to_file manifest, %(//= link_tree ../builds\n)
+      end
+
+      def add_watch_to_procfile
+        procfile = "Procfile.dev"
+        full = File.join(destination_root, procfile)
+        if File.exist?(full)
+          append_to_file procfile, "css: bin/rails sasso:watch\n" unless File.read(full).include?("sasso:watch")
+        else
+          create_file procfile, <<~PROCFILE
+            web: bin/rails server
+            css: bin/rails sasso:watch
+          PROCFILE
+        end
+      end
+
+      # Compile once so `app/assets/builds/application.css` exists and the first
+      # page load (stylesheet_link_tag "application") doesn't 404.
+      def build_initial_css
+        rails_command "sasso:build"
+      end
+
+      def print_instructions
+        say ""
+        say "sasso-rails installed.", :green
+        say "  • Edit app/assets/stylesheets/application.scss"
+        say "  • Reference it with: <%= stylesheet_link_tag \"application\" %>"
+        say "  • Build once:   bin/rails sasso:build"
+        say "  • Watch in dev: bin/rails sasso:watch"
+        say "    (or ./bin/dev, if your app has a Procfile.dev runner like foreman)"
+      end
+
+      private
+
+      def builds_keep_path
+        File.join(destination_root, "app/assets/builds/.keep")
+      end
+
+      def gitignore_path
+        File.join(destination_root, ".gitignore")
+      end
+    end
+  end
+end

data/lib/generators/sasso/install/templates/application.scss

@@ -0,0 +1,13 @@
+// Entrypoint for sasso-rails. This file is compiled by `sasso:build` to
+// app/assets/builds/application.css, which the asset pipeline serves.
+//
+// Use @use to pull in partials (files named _name.scss) from this directory:
+//
+//   @use "components/buttons";
+//
+// Sibling partials resolve automatically; add extra include dirs via
+// config.sasso.load_paths in config/application.rb.
+
+body {
+  margin: 0;
+}

data/lib/sasso/rails/compiler.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Sasso
+  module Rails
+    # Compiles configured Sass/SCSS entrypoints to plain CSS files under the
+    # builds directory. Deliberately Rails-free so it can be unit-tested with a
+    # plain temp `root:` — the Engine just wires `Rails.root` and config in.
+    #
+    #   Sasso::Rails::Compiler.new(
+    #     root:       Rails.root,
+    #     builds:     { "application.scss" => "application.css" },
+    #     style:      :expanded,
+    #     load_paths: [],            # extra dirs, in addition to the source dir
+    #     source_dir: "app/assets/stylesheets",
+    #     build_dir:  "app/assets/builds",
+    #   ).build
+    class Compiler
+      Error = Class.new(StandardError)
+
+      ALLOWED_STYLES = %i[expanded compressed].freeze
+
+      attr_reader :root, :builds, :style, :load_paths, :source_dir, :build_dir
+
+      def initialize(root:, builds:, style: :expanded, load_paths: [],
+                     source_dir: "app/assets/stylesheets",
+                     build_dir: "app/assets/builds")
+        @root       = File.expand_path(root.to_s)
+        @builds     = normalize_builds(builds)
+        @style      = normalize_style(style)
+        @load_paths = Array(load_paths).map(&:to_s)
+        @source_dir = source_dir.to_s
+        @build_dir  = build_dir.to_s
+      end
+
+      # Compile every entrypoint; returns the list of written output paths.
+      def build
+        builds.map { |input, output| build_one(input, output) }
+      end
+
+      # Compile a single `input` (relative to source_dir) to `output` (relative
+      # to build_dir), returning the absolute path written.
+      def build_one(input, output)
+        src = File.join(@root, @source_dir, input)
+        unless File.file?(src)
+          raise Error, "sasso-rails: input stylesheet not found: #{src}"
+        end
+
+        # `Sasso.compile` already searches the entry file's own directory first
+        # (for sibling @use/@import); pass any extra include dirs after it.
+        css = ::Sasso.compile(src, style: @style, load_paths: @load_paths)
+
+        dest = File.join(@root, @build_dir, output)
+        FileUtils.mkdir_p(File.dirname(dest))
+        File.write(dest, css)
+        dest
+      end
+
+      # Recompile whenever a watched source file changes. Dependency-free poll
+      # loop (no `listen` gem): cheap mtime scan of the source + load_path trees.
+      # Blocks. A compile error (including on the FIRST pass) is reported and the
+      # loop keeps running — the watcher must survive a mid-edit broken file.
+      def watch(interval: 1.0)
+        safe_build
+        snapshot = source_mtimes
+        loop do
+          sleep interval
+          current = source_mtimes
+          next if current == snapshot
+
+          snapshot = current
+          safe_build
+        end
+      end
+
+      private
+
+      # Compile, downgrading a Sass/config error to a warning so a watcher does
+      # not die on it (used at startup and on every recompile).
+      def safe_build
+        build
+      rescue ::Sasso::CompileError, Error => e
+        warn e.message
+      end
+
+      # mtime of every .scss/.sass under the source dir AND the configured
+      # load_paths (so editing a shared partial in an include dir also rebuilds).
+      def source_mtimes
+        dirs = [File.join(@root, @source_dir), *@load_paths]
+        dirs.flat_map { |d| Dir.glob(File.join(d, "**", "*.{scss,sass}")) }
+            .uniq.sort.each_with_object({}) do |f, h|
+          h[f] = File.mtime(f).to_f
+        rescue Errno::ENOENT
+          # raced with a delete; skip
+        end
+      end
+
+      # config.sasso.builds must be a non-empty { "input" => "output" } map.
+      def normalize_builds(builds)
+        hash = builds.respond_to?(:to_h) ? builds.to_h : nil
+        if hash.nil? || hash.empty?
+          raise Error, "sasso-rails: config.sasso.builds must be a non-empty Hash " \
+                       'of { "input.scss" => "output.css" }'
+        end
+        hash
+      end
+
+      # Coerce + validate the style (nil/garbage gives a clear error, not a
+      # NoMethodError or an opaque compiler ArgumentError).
+      def normalize_style(style)
+        sym = style.to_s.to_sym
+        unless ALLOWED_STYLES.include?(sym)
+          raise Error, "sasso-rails: config.sasso.style must be one of " \
+                       "#{ALLOWED_STYLES.inspect}, got #{style.inspect}"
+        end
+        sym
+      end
+    end
+  end
+end

data/lib/sasso/rails/engine.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "rails"
+require "active_support/ordered_options"
+
+module Sasso
+  module Rails
+    # Wires sasso into a Rails app. Configurable via `config.sasso.*`:
+    #
+    #   config.sasso.builds     # { "application.scss" => "application.css" }
+    #   config.sasso.style      # :expanded | :compressed (default: env-based)
+    #   config.sasso.load_paths # extra @use/@import include dirs (Array)
+    #   config.sasso.source_dir # default "app/assets/stylesheets"
+    #   config.sasso.build_dir  # default "app/assets/builds"
+    #
+    # The `sasso:build` rake task is enhanced onto `assets:precompile`, so the
+    # CSS is generated before Propshaft/Sprockets fingerprints it on deploy.
+    class Engine < ::Rails::Engine
+      config.sasso = ::ActiveSupport::OrderedOptions.new
+      config.sasso.builds     = { "application.scss" => "application.css" }
+      config.sasso.style      = nil   # resolved in `Sasso::Rails.style_for`
+      config.sasso.load_paths = []
+      config.sasso.source_dir = "app/assets/stylesheets"
+      config.sasso.build_dir  = "app/assets/builds"
+
+      # NOTE: no `rake_tasks do load ... end` — Rails::Engine already auto-loads
+      # lib/tasks/**/*.rake into the host app. Loading it again here would define
+      # each task (and run each `enhance`) twice.
+    end
+
+    module_function
+
+    # Build a Compiler from the running app's config + root.
+    def compiler(app = ::Rails.application)
+      cfg = app.config.sasso
+      Compiler.new(
+        root:       app.root,
+        builds:     cfg.builds,
+        style:      style_for(cfg.style),
+        load_paths: cfg.load_paths,
+        source_dir: cfg.source_dir,
+        build_dir:  cfg.build_dir,
+      )
+    end
+
+    # Default to compressed CSS in production (smaller payload), expanded
+    # elsewhere (readable). An explicit `config.sasso.style` always wins.
+    #
+    # If the asset pipeline has its own CSS compressor (a Sprockets app that set
+    # config.assets.css_compressor), stay :expanded and let the pipeline
+    # compress, avoiding wasteful double-minification. Propshaft sets no
+    # compressor, so production stays :compressed on the default Rails 8 path.
+    def style_for(configured)
+      return configured.to_sym if configured
+      return :expanded if pipeline_css_compressor?
+
+      ::Rails.env.production? ? :compressed : :expanded
+    end
+
+    def pipeline_css_compressor?
+      ::Rails.application&.config&.assets&.css_compressor.present?
+    rescue StandardError
+      false
+    end
+  end
+end

data/lib/sasso/rails/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Sasso
+  module Rails
+    # Versioned INDEPENDENTLY of both the `sasso` gem and the `sasso` crate.
+    # The gemspec pins the engine gem with a range (sasso >= 0.1.1, < 1), so a
+    # compiler bump does not force a lockstep release of this integration gem.
+    VERSION = "0.1.0"
+  end
+end

data/lib/sasso/rails.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "sasso"                 # the compiler engine gem (native extension)
+require "sasso/rails/version"
+require "sasso/rails/compiler"
+
+# Rails integration for the `sasso` SCSS/Sass compiler.
+#
+# Propshaft-first build-task model (mirrors rails/dartsass-rails): compile the
+# configured entrypoints to plain CSS in `app/assets/builds/`, where the asset
+# pipeline (Propshaft on Rails 8, or Sprockets serving it as a static file)
+# fingerprints and serves them. Unlike dartsass-rails/tailwindcss-rails — which
+# shell out to a standalone binary — this calls `Sasso.compile` IN-PROCESS via
+# the native extension, so there is no subprocess, IPC, or binary-path lookup.
+module Sasso
+  module Rails
+    # Loaded only inside a Rails process; the Compiler is usable standalone.
+    require "sasso/rails/engine" if defined?(::Rails::Railtie)
+  end
+end

data/lib/sasso-rails.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# Bundler auto-requires the gem-name file (`sasso-rails`) when an app lists
+# `gem "sasso-rails"`. Delegate to the namespaced entrypoint.
+require "sasso/rails"

data/lib/tasks/sasso_tasks.rake

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+namespace :sasso do
+  desc "Compile the configured Sass/SCSS entrypoints to app/assets/builds"
+  task build: :environment do
+    written = Sasso::Rails.compiler.build
+    written.each { |path| puts "sasso: compiled #{path}" }
+  end
+
+  desc "Watch the source stylesheets and recompile on change (Ctrl-C to stop)"
+  task watch: :environment do
+    compiler = Sasso::Rails.compiler
+    puts "sasso: watching #{compiler.source_dir} ..."
+    compiler.watch
+  rescue Interrupt
+    puts "\nsasso: stopped."
+  end
+
+  desc "Remove the CSS that sasso:build generated"
+  task clobber: :environment do
+    compiler = Sasso::Rails.compiler
+    compiler.builds.each_value do |output|
+      path = File.join(compiler.root, compiler.build_dir, output)
+      next unless File.exist?(path)
+
+      File.delete(path)
+      puts "sasso: removed #{path}"
+    end
+  end
+end
+
+# Generate CSS before the asset pipeline (Propshaft/Sprockets) digests it, and
+# before the test DB/fixtures are prepared so system/feature tests see fresh CSS.
+# Set SKIP_CSS_BUILD=1 to opt out (Docker multi-stage / separate build step).
+unless ENV["SKIP_CSS_BUILD"]
+  if Rake::Task.task_defined?("assets:precompile")
+    Rake::Task["assets:precompile"].enhance(["sasso:build"])
+  end
+
+  # Hook whichever test-prep task this app defines (Minitest / RSpec / DB-only).
+  %w[test:prepare spec:prepare db:test:prepare].each do |t|
+    next unless Rake::Task.task_defined?(t)
+
+    Rake::Task[t].enhance(["sasso:build"])
+    break
+  end
+end
+
+# Keep `rails assets:clobber` symmetric.
+if Rake::Task.task_defined?("assets:clobber")
+  Rake::Task["assets:clobber"].enhance(["sasso:clobber"])
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: sasso-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- momiji-rs
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-06-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+- !ruby/object:Gem::Dependency
+  name: sasso
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+description: Compiles Sass/SCSS to CSS in the Rails asset pipeline (Propshaft-first,
+  Sprockets-compatible) using the in-process sasso native extension — no Node.js,
+  no subprocess.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE-MIT
+- README.md
+- lib/generators/sasso/install/install_generator.rb
+- lib/generators/sasso/install/templates/application.scss
+- lib/sasso-rails.rb
+- lib/sasso/rails.rb
+- lib/sasso/rails/compiler.rb
+- lib/sasso/rails/engine.rb
+- lib/sasso/rails/version.rb
+- lib/tasks/sasso_tasks.rake
+homepage: https://github.com/momiji-rs/sasso-rails
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/momiji-rs/sasso-rails
+  source_code_uri: https://github.com/momiji-rs/sasso-rails
+  changelog_uri: https://github.com/momiji-rs/sasso-rails/blob/main/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: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Rails integration for the sasso SCSS/Sass compiler
+test_files: []