lightningcss 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac2ebda8558d9c647ba99bb0ae17dc67c33f4366a17a565b3cf42ab9c2964a95
-  data.tar.gz: 49f4e08880cfd13d8fef4a4cdd5b17ed8dc75d95c69e955a55814e9ee4d32b89
+  metadata.gz: 0bf26de1f9cfbbb2f49f77242f9597c790753ee59f0d570a9a7a42af2786f546
+  data.tar.gz: 41dcbf4cbdce9e38934fe52b8e594e07cb6c1aa771739309388891597b6f32f8
 SHA512:
-  metadata.gz: a66d61dba36255d63e2bc53633fabd9fc1dc3f3bca456b53c118dcac5421a38ce06930a3e7992d0f7d0c488a16b15ddcd97ccf3d6219cbace4f1dee0befe77fa
-  data.tar.gz: '0709f1ebb8aa6d2f807f1d8593db905d744f39bd9535dcfecf006d13535cf926390120203ca903fc3be651e96ecdb51587f63ddd2c9088b41c09c3d1166aa9c9'
+  metadata.gz: b77a36fd6862d5bcb82d70660ed9a03bbeba0bfa9e817bc223d82670e4a47a159112f0b9956782c320df18835b7e4d011e7f32f4fecd571780ca0607c108744c
+  data.tar.gz: 531fa107ef8aceb5f33fb2da0d23c58a621428d8ddee329bc1d18a4bfc82d04759eec41bbb88d5cb048c16d3ef52f27ff236f1debf7898073f861954720d41bf

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);
@@ -21,6 +30,8 @@ struct LightningCssResult lightningcss_bundle(const char *path, const char *opti
 
 char *lightningcss_version(void);
 
+char *lightningcss_lightningcss_version(void);
+
 void lightningcss_string_free(char *value);
 
 void lightningcss_result_free(struct LightningCssResult result);

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;
-  }
-
-  if (strstr(message, "Invalid scope selector") || strstr(message, "Scope selector")) {
-    return rb_eOptionError;
+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;
   }
-
-  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) {
@@ -85,6 +108,12 @@ static VALUE rb_native_version(VALUE self) {
   return take_utf8_string(lightningcss_version());
 }
 
+static VALUE rb_lightningcss_version(VALUE self) {
+  (void) self;
+
+  return take_utf8_string(lightningcss_lightningcss_version());
+}
+
 void Init_lightningcss(void) {
   rb_mLightningCSS = rb_define_module("LightningCSS");
   rb_mBackend = rb_define_module_under(rb_mLightningCSS, "Backend");
@@ -98,4 +127,5 @@ void Init_lightningcss(void) {
   rb_define_singleton_method(rb_mBackend, "transform_style_attribute", rb_transform_style_attribute, 2);
   rb_define_singleton_method(rb_mBackend, "bundle", rb_bundle, 2);
   rb_define_singleton_method(rb_mBackend, "version", rb_native_version, 0);
+  rb_define_singleton_method(rb_mBackend, "lightningcss_version", rb_lightningcss_version, 0);
 }

data/lib/lightningcss/backend.rb

@@ -23,6 +23,11 @@ module LightningCSS
         unavailable(__method__)
       end
 
+      #: () -> String
+      def lightningcss_version
+        unavailable(__method__)
+      end
+
       private
 
       #: (Symbol?) -> bot

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.0"
+  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
@@ -54,7 +56,7 @@ module LightningCSS
   end
 
   #: () -> String
-  def self.native_version
-    Backend.version
+  def self.lightningcss_version
+    Backend.lightningcss_version
   end
 end

data/lightningcss.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.summary = "An extremely fast CSS parser, transformer, bundler, and minifier."
   spec.description = "Ruby bindings for Lightning CSS, an extremely fast CSS parser, transformer, bundler, and minifier."
   spec.homepage = "https://github.com/marcoroth/lightningcss-ruby"
-  spec.license = "MIT"
+  spec.licenses = ["MIT", "MPL-2.0"]
   spec.required_ruby_version = ">= 3.2.0"
   spec.require_paths = ["lib"]
 

data/rust/Cargo.lock

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

data/rust/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "lightningcss-ffi"
-version = "0.1.0"
+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

@@ -1,4 +1,5 @@
 use std::env;
+use std::fs;
 use std::path::PathBuf;
 
 fn main() {
@@ -12,4 +13,43 @@ fn main() {
 
     bindings.write_to_file(&header_path);
   }
+
+  let lock_path = PathBuf::from(&crate_dir).join("Cargo.lock");
+
+  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")
+  );
+}
+
+fn locked_version(lock_path: &PathBuf, package: &str) -> String {
+  let Ok(lock) = fs::read_to_string(lock_path) else {
+    return "unknown".to_string();
+  };
+
+  let mut lines = lock.lines();
+
+  while let Some(line) = lines.next() {
+    if line.trim() != format!("name = \"{package}\"") {
+      continue;
+    }
+
+    if let Some(version) = lines.next().and_then(|next| next.trim().strip_prefix("version = ")) {
+      return version.trim_matches('"').to_string();
+    }
+  }
+
+  "unknown".to_string()
 }

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;
 
@@ -25,11 +25,23 @@ use crate::options::{TransformOptions, TransformResult};
 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 {
@@ -37,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(),
     }
   }
 }
@@ -52,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());
   }
@@ -73,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,
   };
 
@@ -93,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();
@@ -111,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
@@ -123,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
@@ -144,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();
@@ -179,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
@@ -188,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();
 
@@ -219,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,
@@ -228,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),
   }
 }
 
@@ -245,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))
@@ -263,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))
@@ -278,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))
@@ -294,6 +361,11 @@ pub unsafe extern "C" fn lightningcss_version() -> *mut c_char {
   into_c_string(VERSION)
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn lightningcss_lightningcss_version() -> *mut c_char {
+  into_c_string(LIGHTNINGCSS_VERSION)
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn lightningcss_string_free(value: *mut c_char) {
   if !value.is_null() {

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/backend.rbs

@@ -15,6 +15,9 @@ module LightningCSS
       # : () -> String
       def version: () -> String
 
+      # : () -> String
+      def lightningcss_version: () -> String
+
       private
 
       # : (Symbol?) -> bot

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
@@ -27,5 +27,5 @@ module LightningCSS
   def self.minify: (String, ?filename: String?, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> String
 
   # : () -> String
-  def self.native_version: () -> String
+  def self.lightningcss_version: () -> String
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lightningcss
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Marco Roth
@@ -52,6 +52,7 @@ files:
 homepage: https://github.com/marcoroth/lightningcss-ruby
 licenses:
 - MIT
+- MPL-2.0
 metadata:
   homepage_uri: https://github.com/marcoroth/lightningcss-ruby
   source_code_uri: https://github.com/marcoroth/lightningcss-ruby