lightningcss 0.1.1-x86_64-linux-gnu → 0.2.0-x86_64-linux-gnu

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a31e0134417336ea23e7b77bce94afcf4575099402dea938d25acf44a5b2a2c8
-  data.tar.gz: d397464d5c09dad2e61daf7860a80043302e10961a4dd945e6204041b5bd9fd6
+  metadata.gz: 60b9bf5ff6f7226f2deb903411280800ba1bb5e4d270fd32cc7c28ae23f82e54
+  data.tar.gz: 3199cdeaca6c86296bd0d05c7350d450694e00c71d26a72a9cfe70acbc71e249
 SHA512:
-  metadata.gz: 9107d3e0bdb0eb491451820b314dcf87df50401b482c84e870b12b7e77b3d3a750e881a027d5b7efb50749681280e7c8dcf16a481f10bb93f175648365741c62
-  data.tar.gz: ea0cbbfb82490f5c5d811d014b840cd3bba1d45e3b4a64b522ba27e71b57d583d9c96014457edf32989ba96716786b03aba56c952084911bcbd1c58b5c23d8ef
+  metadata.gz: 562c17a0bedbc7c0c971b20df9da6352b108b1607321f9ada7021c6d696515e8a371003a78ed90b4bd69fd60c01b6027016414f834cb5d5e27206a5e6b4c57e3
+  data.tar.gz: e0b92d822c7244d589aa00c021338c27455cbaf845494eeac942a01a29e8c346b47141d7a87c752337d2a52152a51a5332fbcf1277deabc7873492b4da211e3f

data/README.md

@@ -62,6 +62,20 @@ LightningCSS.transform(".a { color: lab(50% 40 59) }", targets: { chrome: 80 },
 LightningCSS.bundle("app/assets/stylesheets/application.css", minify: true).code
 ```
 
+A bundle names every file it reads by the path it read it from, so it takes no `filename` and says so when given one.
+
+It answers the same result a transform does. Every warning names the file it came from, and compiling as a CSS module renames the names in every file it read while exporting the ones the entry wrote. A file it imported is hashed on its own, so its names never collide with the entry's.
+
+```ruby
+result = LightningCSS.bundle("app/assets/stylesheets/application.css", css_modules: true)
+
+result.exports
+#=> {"application" => "_8Z4fiW_application"}
+
+result.warnings.first
+#=> "'deep' is not recognized as a valid pseudo-class. ... at app/assets/stylesheets/layout.css:0:9"
+```
+
 #### CSS modules
 
 Compiling as a CSS module renames every class, id, `@keyframes`, and custom identifier, and reports what each name became.

data/ext/lightningcss/extconf.rb

@@ -65,12 +65,12 @@ if target_platform
 
   system("rustup target add #{target_platform}") || warn("lightningcss: Failed to add Rust target #{target_platform}")
 
-  cargo_args = "--release --target #{target_platform}"
+  cargo_args = "--release --locked --target #{target_platform}"
   lib_dir = File.join(target_dir, target_platform, "release")
 else
   puts "lightningcss: Compiling Rust library for native platform..."
 
-  cargo_args = "--release"
+  cargo_args = "--release --locked"
   lib_dir = File.join(target_dir, "release")
 end
 
@@ -84,7 +84,18 @@ end
 
 static_lib = File.join(lib_dir, "liblightningcss_ffi.a")
 
-if File.exist?(static_lib)
+developing = File.exist?(File.join(root_dir, ".git"))
+
+if File.exist?(static_lib) && !developing
+  vendored = File.join(ext_dir, "liblightningcss_ffi.a")
+
+  FileUtils.cp(static_lib, vendored)
+  FileUtils.rm_rf(target_dir)
+
+  puts "lightningcss: Static library vendored at #{vendored}, Rust build directory removed"
+
+  $LDFLAGS << " #{vendored}"
+elsif File.exist?(static_lib)
   puts "lightningcss: Static library found at #{static_lib}"
 
   $LDFLAGS << " #{static_lib}"

data/ext/lightningcss/include/lightningcss.h

@@ -7,9 +7,18 @@
 #ifndef LIGHTNINGCSS_H
 #define LIGHTNINGCSS_H
 
+typedef enum LightningCssErrorCode {
+  LIGHTNING_CSS_ERROR_CODE_NONE = 0,
+  LIGHTNING_CSS_ERROR_CODE_PARSE,
+  LIGHTNING_CSS_ERROR_CODE_OPTION,
+  LIGHTNING_CSS_ERROR_CODE_BUNDLE,
+  LIGHTNING_CSS_ERROR_CODE_INTERNAL,
+} LightningCssErrorCode;
+
 typedef struct LightningCssResult {
   char *value;
   char *error;
+  enum LightningCssErrorCode code;
 } LightningCssResult;
 
 struct LightningCssResult lightningcss_transform(const char *code, const char *options_json);

data/ext/lightningcss/lightningcss.c

@@ -1,5 +1,6 @@
 #include <ruby.h>
 #include <ruby/encoding.h>
+#include <ruby/thread.h>
 #include "include/lightningcss.h"
 
 static VALUE rb_mLightningCSS;
@@ -9,6 +10,15 @@ static VALUE rb_eParseError;
 static VALUE rb_eOptionError;
 static VALUE rb_eBundleError;
 
+typedef struct LightningCssResult (*lightningcss_function)(const char *, const char *);
+
+struct call_arguments {
+  lightningcss_function function;
+  const char *input;
+  const char *options;
+  struct LightningCssResult result;
+};
+
 static VALUE make_utf8_string(const char *cstring) {
   return rb_enc_str_new_cstr(cstring, rb_utf8_encoding());
 }
@@ -22,26 +32,19 @@ static VALUE take_utf8_string(char *cstring) {
   return string;
 }
 
-static VALUE error_class_for(const char *message) {
-  if (strstr(message, "Invalid options") || strstr(message, "Invalid CSS modules pattern")) {
-    return rb_eOptionError;
-  }
-
-  if (strstr(message, "os error") || strstr(message, "No such file")) {
-    return rb_eBundleError;
+static VALUE error_class_for(enum LightningCssErrorCode code) {
+  switch (code) {
+    case LIGHTNING_CSS_ERROR_CODE_PARSE: return rb_eParseError;
+    case LIGHTNING_CSS_ERROR_CODE_OPTION: return rb_eOptionError;
+    case LIGHTNING_CSS_ERROR_CODE_BUNDLE: return rb_eBundleError;
+    default: return rb_eError;
   }
-
-  if (strstr(message, "Invalid scope selector") || strstr(message, "Scope selector")) {
-    return rb_eOptionError;
-  }
-
-  return rb_eParseError;
 }
 
 static VALUE unwrap(struct LightningCssResult result) {
   if (result.error) {
     VALUE message = make_utf8_string(result.error);
-    VALUE error_class = error_class_for(result.error);
+    VALUE error_class = error_class_for(result.code);
 
     lightningcss_result_free(result);
 
@@ -61,22 +64,42 @@ static VALUE unwrap(struct LightningCssResult result) {
   return value;
 }
 
+static void *without_gvl(void *data) {
+  struct call_arguments *arguments = (struct call_arguments *) data;
+
+  arguments->result = arguments->function(arguments->input, arguments->options);
+
+  return NULL;
+}
+
+static VALUE call(lightningcss_function function, VALUE input, VALUE options) {
+  struct call_arguments arguments;
+
+  arguments.function = function;
+  arguments.input = StringValueCStr(input);
+  arguments.options = StringValueCStr(options);
+
+  rb_thread_call_without_gvl(without_gvl, &arguments, NULL, NULL);
+
+  return unwrap(arguments.result);
+}
+
 static VALUE rb_transform(VALUE self, VALUE code, VALUE options) {
   (void) self;
 
-  return unwrap(lightningcss_transform(StringValueCStr(code), StringValueCStr(options)));
+  return call(lightningcss_transform, code, options);
 }
 
 static VALUE rb_transform_style_attribute(VALUE self, VALUE code, VALUE options) {
   (void) self;
 
-  return unwrap(lightningcss_transform_style_attribute(StringValueCStr(code), StringValueCStr(options)));
+  return call(lightningcss_transform_style_attribute, code, options);
 }
 
 static VALUE rb_bundle(VALUE self, VALUE path, VALUE options) {
   (void) self;
 
-  return unwrap(lightningcss_bundle(StringValueCStr(path), StringValueCStr(options)));
+  return call(lightningcss_bundle, path, options);
 }
 
 static VALUE rb_native_version(VALUE self) {

data/lib/lightningcss/options.rb

@@ -26,15 +26,23 @@ module LightningCSS
       :targets
     ].freeze #: Array[Symbol]
 
+    BUNDLE = [
+      :minify,
+      :error_recovery,
+      :targets,
+      :css_modules,
+      :scope
+    ].freeze #: Array[Symbol]
+
     attr_reader :to_h #: Hash[Symbol, untyped]
 
-    #: (Hash[Symbol, untyped], ?allowed: Array[Symbol], ?subject: String) -> String
-    def self.serialize(options, allowed: KNOWN, subject: "a transform")
-      new(allowed: allowed, subject: subject, **options).to_json
+    #: (Hash[Symbol, untyped], ?Array[Symbol], ?String) -> String
+    def self.serialize(options, allowed = KNOWN, subject = "a transform")
+      new(options, allowed, subject).to_json
     end
 
-    #: (?allowed: Array[Symbol], ?subject: String, **untyped) -> void
-    def initialize(allowed: KNOWN, subject: "a transform", **options)
+    #: (Hash[Symbol, untyped], ?Array[Symbol], ?String) -> void
+    def initialize(options, allowed = KNOWN, subject = "a transform")
       given = options.transform_keys(&:to_sym)
 
       validate!(given.keys, allowed, subject)

data/lib/lightningcss/transformer.rb

@@ -28,7 +28,7 @@ module LightningCSS
 
     alias call transform
 
-    #: (String, ?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
+    #: (String, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
     def bundle(path, **overrides)
       LightningCSS.bundle(path, **options, **overrides)
     end

data/lib/lightningcss/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LightningCSS
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/lightningcss.rb

@@ -36,14 +36,16 @@ module LightningCSS
     Result.from_json(Backend.transform(code.to_s, Options.serialize(options)))
   end
 
-  #: (String, ?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
+  #: (String, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
   def self.bundle(path, **options)
-    Result.from_json(Backend.bundle(path.to_s, Options.serialize(options)))
+    serialized = Options.serialize(options, Options::BUNDLE, "a bundle")
+
+    Result.from_json(Backend.bundle(path.to_s, serialized))
   end
 
   #: (String, ?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?) -> LightningCSS::Result
   def self.transform_style_attribute(code, **options)
-    serialized = Options.serialize(options, allowed: Options::STYLE_ATTRIBUTE, subject: "a style attribute")
+    serialized = Options.serialize(options, Options::STYLE_ATTRIBUTE, "a style attribute")
 
     Result.from_json(Backend.transform_style_attribute(code.to_s, serialized))
   end

data/rust/Cargo.lock

@@ -527,7 +527,7 @@ dependencies = [
 
 [[package]]
 name = "lightningcss-ffi"
-version = "0.1.1"
+version = "0.2.0"
 dependencies = [
  "cbindgen",
  "lightningcss",

data/rust/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "lightningcss-ffi"
-version = "0.1.1"
+version = "0.2.0"
 edition = "2021"
 authors = ["Marco Roth <marco.roth@intergga.ch>"]
 description = "C FFI bindings for Lightning CSS, used by the lightningcss gem"

data/rust/build.rs

@@ -18,6 +18,16 @@ fn main() {
 
   println!("cargo:rerun-if-changed={}", lock_path.display());
 
+  println!(
+    "cargo:rerun-if-changed={}",
+    PathBuf::from(&crate_dir).join("src").display()
+  );
+
+  println!(
+    "cargo:rerun-if-changed={}",
+    PathBuf::from(&crate_dir).join("cbindgen.toml").display()
+  );
+
   println!(
     "cargo:rustc-env=LIGHTNINGCSS_VERSION={}",
     locked_version(&lock_path, "lightningcss")

data/rust/cbindgen.toml

@@ -10,6 +10,7 @@ no_includes = true
 [export]
 include = [
   "LightningCssResult",
+  "LightningCssErrorCode",
 ]
 
 [enum]

data/rust/src/lib.rs

@@ -17,7 +17,7 @@ use std::os::raw::c_char;
 use std::ptr;
 use std::sync::{Arc, RwLock};
 
-use lightningcss::bundler::{Bundler, FileProvider};
+use lightningcss::bundler::{BundleErrorKind, Bundler, FileProvider};
 use lightningcss::stylesheet::{MinifyOptions, ParserOptions, PrinterOptions, StyleAttribute, StyleSheet};
 use lightningcss::visitor::Visit;
 
@@ -27,10 +27,21 @@ use crate::scope::Scoper;
 pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 pub const LIGHTNINGCSS_VERSION: &str = env!("LIGHTNINGCSS_VERSION");
 
+#[repr(C)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum LightningCssErrorCode {
+  None = 0,
+  Parse,
+  Option,
+  Bundle,
+  Internal,
+}
+
 #[repr(C)]
 pub struct LightningCssResult {
   pub value: *mut c_char,
   pub error: *mut c_char,
+  pub code: LightningCssErrorCode,
 }
 
 impl LightningCssResult {
@@ -38,13 +49,50 @@ impl LightningCssResult {
     Self {
       value: into_c_string(value),
       error: ptr::null_mut(),
+      code: LightningCssErrorCode::None,
     }
   }
 
-  fn err(message: impl AsRef<str>) -> Self {
+  fn err(failure: Failure) -> Self {
     Self {
       value: ptr::null_mut(),
-      error: into_c_string(message.as_ref()),
+      error: into_c_string(failure.message),
+      code: failure.code,
+    }
+  }
+}
+
+pub struct Failure {
+  code: LightningCssErrorCode,
+  message: String,
+}
+
+impl Failure {
+  fn parse(message: impl Into<String>) -> Self {
+    Self {
+      code: LightningCssErrorCode::Parse,
+      message: message.into(),
+    }
+  }
+
+  fn option(message: impl Into<String>) -> Self {
+    Self {
+      code: LightningCssErrorCode::Option,
+      message: message.into(),
+    }
+  }
+
+  fn bundle(message: impl Into<String>) -> Self {
+    Self {
+      code: LightningCssErrorCode::Bundle,
+      message: message.into(),
+    }
+  }
+
+  fn internal(message: impl Into<String>) -> Self {
+    Self {
+      code: LightningCssErrorCode::Internal,
+      message: message.into(),
     }
   }
 }
@@ -53,17 +101,17 @@ fn into_c_string(value: impl Into<Vec<u8>>) -> *mut c_char {
   CString::new(value).unwrap_or_default().into_raw()
 }
 
-unsafe fn borrow_str<'a>(pointer: *const c_char, label: &str) -> Result<&'a str, String> {
+unsafe fn borrow_str<'a>(pointer: *const c_char, label: &str) -> Result<&'a str, Failure> {
   if pointer.is_null() {
-    return Err(format!("{label} is null"));
+    return Err(Failure::internal(format!("{label} is null")));
   }
 
   CStr::from_ptr(pointer)
     .to_str()
-    .map_err(|error| format!("Invalid UTF-8 in {label}: {error}"))
+    .map_err(|error| Failure::internal(format!("Invalid UTF-8 in {label}: {error}")))
 }
 
-unsafe fn borrow_options(pointer: *const c_char) -> Result<TransformOptions, String> {
+unsafe fn borrow_options(pointer: *const c_char) -> Result<TransformOptions, Failure> {
   if pointer.is_null() {
     return Ok(TransformOptions::default());
   }
@@ -74,13 +122,13 @@ unsafe fn borrow_options(pointer: *const c_char) -> Result<TransformOptions, Str
     return Ok(TransformOptions::default());
   }
 
-  serde_json::from_str(json).map_err(|error| format!("Invalid options: {error}"))
+  serde_json::from_str(json).map_err(|error| Failure::option(format!("Invalid options: {error}")))
 }
 
-fn transform_source(code: &str, options: &TransformOptions) -> Result<TransformResult, String> {
+fn transform_source(code: &str, options: &TransformOptions) -> Result<TransformResult, Failure> {
   let filename = options.filename.clone().unwrap_or_default();
   let css_modules = match &options.css_modules {
-    Some(modules) => Some(modules.to_config()?),
+    Some(modules) => Some(modules.to_config().map_err(Failure::option)?),
     None => None,
   };
 
@@ -94,14 +142,14 @@ fn transform_source(code: &str, options: &TransformOptions) -> Result<TransformR
     ..ParserOptions::default()
   };
 
-  let mut stylesheet = StyleSheet::parse(code, parser_options).map_err(|error| error.to_string())?;
+  let mut stylesheet = StyleSheet::parse(code, parser_options).map_err(|error| Failure::parse(error.to_string()))?;
 
   if let Some(fragment) = &options.scope {
-    let mut scoper = Scoper::parse(fragment)?;
+    let mut scoper = Scoper::parse(fragment).map_err(Failure::option)?;
 
     stylesheet
       .visit(&mut scoper)
-      .map_err(|error| format!("Failed to scope stylesheet: {error:?}"))?;
+      .map_err(|error| Failure::internal(format!("Failed to scope stylesheet: {error:?}")))?;
   }
 
   let targets = options.to_targets();
@@ -112,7 +160,7 @@ fn transform_source(code: &str, options: &TransformOptions) -> Result<TransformR
         targets,
         ..MinifyOptions::default()
       })
-      .map_err(|error| format!("Failed to minify: {error}"))?;
+      .map_err(|error| Failure::internal(format!("Failed to minify: {error}")))?;
   }
 
   let printed = stylesheet
@@ -124,7 +172,7 @@ fn transform_source(code: &str, options: &TransformOptions) -> Result<TransformR
       analyze_dependencies: None,
       pseudo_classes: None,
     })
-    .map_err(|error| format!("Failed to print: {error}"))?;
+    .map_err(|error| Failure::internal(format!("Failed to print: {error}")))?;
 
   let exports = printed.exports.map(|exports| {
     exports
@@ -145,31 +193,37 @@ fn transform_source(code: &str, options: &TransformOptions) -> Result<TransformR
   })
 }
 
-fn bundle_source(path: &str, options: &TransformOptions) -> Result<TransformResult, String> {
+fn bundle_source(path: &str, options: &TransformOptions) -> Result<TransformResult, Failure> {
   let css_modules = match &options.css_modules {
-    Some(modules) => Some(modules.to_config()?),
+    Some(modules) => Some(modules.to_config().map_err(Failure::option)?),
     None => None,
   };
 
+  let provider = FileProvider::new();
+  let collected = Arc::new(RwLock::new(Vec::new()));
+
   let parser_options = ParserOptions {
     css_modules,
     error_recovery: options.error_recovery,
+    warnings: Some(collected.clone()),
     ..ParserOptions::default()
   };
 
-  let provider = FileProvider::new();
   let mut bundler = Bundler::new(&provider, None, parser_options);
 
   let mut stylesheet = bundler
     .bundle(std::path::Path::new(path))
-    .map_err(|error| error.to_string())?;
+    .map_err(|error| match &error.kind {
+      BundleErrorKind::ParserError(_) => Failure::parse(error.to_string()),
+      _ => Failure::bundle(error.to_string()),
+    })?;
 
   if let Some(fragment) = &options.scope {
-    let mut scoper = Scoper::parse(fragment)?;
+    let mut scoper = Scoper::parse(fragment).map_err(Failure::option)?;
 
     stylesheet
       .visit(&mut scoper)
-      .map_err(|error| format!("Failed to scope stylesheet: {error:?}"))?;
+      .map_err(|error| Failure::internal(format!("Failed to scope stylesheet: {error:?}")))?;
   }
 
   let targets = options.to_targets();
@@ -180,7 +234,7 @@ fn bundle_source(path: &str, options: &TransformOptions) -> Result<TransformResu
         targets,
         ..MinifyOptions::default()
       })
-      .map_err(|error| format!("Failed to minify: {error}"))?;
+      .map_err(|error| Failure::internal(format!("Failed to minify: {error}")))?;
   }
 
   let printed = stylesheet
@@ -189,23 +243,35 @@ fn bundle_source(path: &str, options: &TransformOptions) -> Result<TransformResu
       targets,
       ..PrinterOptions::default()
     })
-    .map_err(|error| format!("Failed to print: {error}"))?;
+    .map_err(|error| Failure::internal(format!("Failed to print: {error}")))?;
+
+  let exports = printed.exports.map(|exports| {
+    exports
+      .into_iter()
+      .map(|(local, export)| (local, export.name))
+      .collect::<HashMap<String, String>>()
+  });
+
+  let warnings = collected
+    .read()
+    .map(|warnings| warnings.iter().map(|warning| warning.to_string()).collect())
+    .unwrap_or_default();
 
   Ok(TransformResult {
     code: printed.code,
-    exports: None,
-    warnings: Vec::new(),
+    exports,
+    warnings,
   })
 }
 
-fn transform_attribute(code: &str, options: &TransformOptions) -> Result<TransformResult, String> {
+fn transform_attribute(code: &str, options: &TransformOptions) -> Result<TransformResult, Failure> {
   let parser_options = ParserOptions {
     filename: options.filename.clone().unwrap_or_default(),
     error_recovery: options.error_recovery,
     ..ParserOptions::default()
   };
 
-  let mut attribute = StyleAttribute::parse(code, parser_options).map_err(|error| error.to_string())?;
+  let mut attribute = StyleAttribute::parse(code, parser_options).map_err(|error| Failure::parse(error.to_string()))?;
 
   let targets = options.to_targets();
 
@@ -220,7 +286,7 @@ fn transform_attribute(code: &str, options: &TransformOptions) -> Result<Transfo
       targets,
       ..PrinterOptions::default()
     })
-    .map_err(|error| format!("Failed to print: {error}"))?;
+    .map_err(|error| Failure::internal(format!("Failed to print: {error}")))?;
 
   Ok(TransformResult {
     code: printed.code,
@@ -229,13 +295,13 @@ fn transform_attribute(code: &str, options: &TransformOptions) -> Result<Transfo
   })
 }
 
-fn to_result(outcome: Result<TransformResult, String>) -> LightningCssResult {
+fn to_result(outcome: Result<TransformResult, Failure>) -> LightningCssResult {
   match outcome {
     Ok(result) => match serde_json::to_string(&result) {
       Ok(json) => LightningCssResult::ok(json),
-      Err(error) => LightningCssResult::err(format!("Failed to serialize result: {error}")),
+      Err(error) => LightningCssResult::err(Failure::internal(format!("Failed to serialize result: {error}"))),
     },
-    Err(message) => LightningCssResult::err(message),
+    Err(failure) => LightningCssResult::err(failure),
   }
 }
 
@@ -246,12 +312,12 @@ pub unsafe extern "C" fn lightningcss_transform(
 ) -> LightningCssResult {
   let code = match borrow_str(code, "code") {
     Ok(code) => code,
-    Err(message) => return LightningCssResult::err(message),
+    Err(failure) => return LightningCssResult::err(failure),
   };
 
   let options = match borrow_options(options_json) {
     Ok(options) => options,
-    Err(message) => return LightningCssResult::err(message),
+    Err(failure) => return LightningCssResult::err(failure),
   };
 
   to_result(transform_source(code, &options))
@@ -264,12 +330,12 @@ pub unsafe extern "C" fn lightningcss_transform_style_attribute(
 ) -> LightningCssResult {
   let code = match borrow_str(code, "code") {
     Ok(code) => code,
-    Err(message) => return LightningCssResult::err(message),
+    Err(failure) => return LightningCssResult::err(failure),
   };
 
   let options = match borrow_options(options_json) {
     Ok(options) => options,
-    Err(message) => return LightningCssResult::err(message),
+    Err(failure) => return LightningCssResult::err(failure),
   };
 
   to_result(transform_attribute(code, &options))
@@ -279,12 +345,12 @@ pub unsafe extern "C" fn lightningcss_transform_style_attribute(
 pub unsafe extern "C" fn lightningcss_bundle(path: *const c_char, options_json: *const c_char) -> LightningCssResult {
   let path = match borrow_str(path, "path") {
     Ok(path) => path,
-    Err(message) => return LightningCssResult::err(message),
+    Err(failure) => return LightningCssResult::err(failure),
   };
 
   let options = match borrow_options(options_json) {
     Ok(options) => options,
-    Err(message) => return LightningCssResult::err(message),
+    Err(failure) => return LightningCssResult::err(failure),
   };
 
   to_result(bundle_source(path, &options))

data/rust/src/scope.rs

@@ -4,8 +4,10 @@
 //! `parcel_selectors` stores a selector in reverse match order, so `Selector::append` lands the
 //! fragment in the last compound and before any pseudo-element, which is where a scope belongs:
 //!
-//!     .card .title    ->  .card .title[data-herb-scope-abc]
-//!     .item::before   ->  .item[data-herb-scope-abc]::before
+//! ```text
+//! .card .title    ->  .card .title[data-herb-scope-abc]
+//! .item::before   ->  .item[data-herb-scope-abc]::before
+//! ```
 //!
 //! A fragment is anything that parses as one compound selector, so an attribute and a `:where()`
 //! carrying its own alternatives are both expressible.

data/sig/lightningcss/options.rbs

@@ -13,13 +13,15 @@ module LightningCSS
 
     STYLE_ATTRIBUTE: Array[Symbol]
 
+    BUNDLE: Array[Symbol]
+
     attr_reader to_h: Hash[Symbol, untyped]
 
-    # : (Hash[Symbol, untyped], ?allowed: Array[Symbol], ?subject: String) -> String
-    def self.serialize: (Hash[Symbol, untyped], ?allowed: Array[Symbol], ?subject: String) -> String
+    # : (Hash[Symbol, untyped], ?Array[Symbol], ?String) -> String
+    def self.serialize: (Hash[Symbol, untyped], ?Array[Symbol], ?String) -> String
 
-    # : (?allowed: Array[Symbol], ?subject: String, **untyped) -> void
-    def initialize: (?allowed: Array[Symbol], ?subject: String, **untyped) -> void
+    # : (Hash[Symbol, untyped], ?Array[Symbol], ?String) -> void
+    def initialize: (Hash[Symbol, untyped], ?Array[Symbol], ?String) -> void
 
     # : (?untyped) -> String
     def to_json: (?untyped) -> String

data/sig/lightningcss/transformer.rbs

@@ -21,8 +21,8 @@ module LightningCSS
 
     alias call transform
 
-    # : (String, ?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
-    def bundle: (String, ?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
+    # : (String, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
+    def bundle: (String, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
 
     # : (String, ?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?) -> LightningCSS::Result
     def transform_style_attribute: (String, ?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?) -> LightningCSS::Result

data/sig/lightningcss.rbs

@@ -17,8 +17,8 @@ module LightningCSS
   # : (String, ?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
   def self.transform: (String, ?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
 
-  # : (String, ?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
-  def self.bundle: (String, ?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
+  # : (String, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
+  def self.bundle: (String, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
 
   # : (String, ?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?) -> LightningCSS::Result
   def self.transform_style_attribute: (String, ?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?) -> LightningCSS::Result

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lightningcss
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: x86_64-linux-gnu
 authors:
 - Marco Roth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-08-24 00:00:00.000000000 Z
+date: 2026-08-30 00:00:00.000000000 Z
 dependencies: []
 description: Ruby bindings for Lightning CSS, an extremely fast CSS parser, transformer,
   bundler, and minifier.