lightningcss 1.33.0-aarch64-linux-gnu → 1.33.0.2-aarch64-linux-gnu

data/lib/lightningcss/visitor.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module LightningCSS
+  # Walks an AST, answering each node with the method named after it and walking through anything
+  # nothing answers.
+  #
+  #     class Colors < LightningCSS::Visitor
+  #       def visit_declaration(node)
+  #         puts node.value.type if node.property == "color"
+  #       end
+  #     end
+  #
+  #     Colors.new.visit(LightningCSS.parse(".a { color: red }"))
+  #
+  # A rule is answered as one, as in `visit_style_rule` or `visit_media_rule`, since `style`,
+  # `nesting`, and `namespace` are also what a selector is made of.
+  #
+  class Visitor
+    #: (LightningCSS::Node | LightningCSS::ParseResult) -> void
+    def visit(node)
+      node = node.root if node.is_a?(ParseResult)
+
+      method_name = "visit_#{node.underscored_type}" if node.underscored_type
+
+      method_name && respond_to?(method_name) ? public_send(method_name, node) : visit_children(node)
+
+      nil
+    end
+
+    #: (LightningCSS::Node) -> void
+    def visit_children(node)
+      node.child_nodes.each { |child| visit(child) }
+
+      nil
+    end
+  end
+end

data/lib/lightningcss/warning.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module LightningCSS
+  class Warning
+    attr_reader :message #: String
+    attr_reader :type #: String?
+    attr_reader :location #: LightningCSS::Location?
+
+    #: (Hash[String, untyped]) -> LightningCSS::Warning
+    def self.from_hash(hash)
+      new(
+        message: hash.fetch("message"),
+        type: hash["type"],
+        location: hash["location"] && Location.from_hash(hash["location"])
+      )
+    end
+
+    #: (message: String, ?type: String?, ?location: LightningCSS::Location?) -> void
+    def initialize(message:, type: nil, location: nil)
+      @message = message
+      @type = type
+      @location = location
+
+      freeze
+    end
+
+    #: () -> Hash[Symbol, untyped]
+    def to_h
+      { message: message, type: type, location: location&.to_h }
+    end
+
+    #: () -> String
+    def to_s
+      location ? "#{message} at #{location}" : message
+    end
+
+    alias to_str to_s
+
+    #: (untyped) -> bool
+    def ==(other)
+      case other
+      when Warning then to_h == other.to_h
+      when String then to_s == other
+      else false
+      end
+    end
+
+    alias eql? ==
+
+    #: () -> Integer
+    def hash
+      to_h.hash
+    end
+
+    #: () -> String
+    def inspect
+      "#<#{self.class.name} #{to_s.inspect}>"
+    end
+  end
+end

data/lib/lightningcss.rb

@@ -3,6 +3,7 @@
 require "json"
 
 require_relative "lightningcss/version"
+require_relative "lightningcss/location"
 require_relative "lightningcss/errors"
 require_relative "lightningcss/backend"
 
@@ -14,7 +15,11 @@ rescue LoadError
 end
 
 require_relative "lightningcss/options"
+require_relative "lightningcss/warning"
 require_relative "lightningcss/result"
+require_relative "lightningcss/node"
+require_relative "lightningcss/parse_result"
+require_relative "lightningcss/visitor"
 require_relative "lightningcss/transformer"
 
 # Ruby bindings for Lightning CSS.
@@ -28,14 +33,27 @@ require_relative "lightningcss/transformer"
 #     LightningCSS.transform(".title { color: red }", scope: "[data-scope-abc]").code
 #     #=> ".title[data-scope-abc]{color:red}"
 #
+# `parse` returns the AST instead, to walk with `LightningCSS::Node` and `LightningCSS::Visitor`:
+#
+#     LightningCSS.parse(".a { color: red }").root.every("declaration").first.property
+#     #=> "color"
+#
 # `LightningCSS::Options` is what the options are read by, and `LightningCSS::Transformer` holds a
 # set of them to reuse across many stylesheets.
+#
 module LightningCSS
   #: (String, ?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
   def self.transform(code, **options)
     Result.from_json(Backend.transform(code.to_s, Options.serialize(options)))
   end
 
+  #: (String, ?filename: String?, ?error_recovery: bool) -> LightningCSS::ParseResult
+  def self.parse(code, **options)
+    serialized = Options.serialize(options, Options::PARSE, "a parse")
+
+    ParseResult.from_json(Backend.parse(code.to_s, serialized), code.to_s)
+  end
+
   #: (String, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
   def self.bundle(path, **options)
     serialized = Options.serialize(options, Options::BUNDLE, "a bundle")

data/rust/Cargo.lock

@@ -90,6 +90,9 @@ name = "bitflags"
 version = "2.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b588b76d00fde79687d7646a9b5bdf3cc0f655e0bbd080335a95d7e96f3587da"
+dependencies = [
+ "serde_core",
+]
 
 [[package]]
 name = "bitvec"
@@ -245,6 +248,7 @@ dependencies = [
  "dtoa-short",
  "itoa",
  "phf 0.13.1",
+ "serde",
  "smallvec",
 ]
 
@@ -511,6 +515,7 @@ dependencies = [
  "serde",
  "serde-content",
  "smallvec",
+ "static-self",
 ]
 
 [[package]]
@@ -599,7 +604,9 @@ dependencies = [
  "phf_codegen",
  "precomputed-hash",
  "rustc-hash",
+ "serde",
  "smallvec",
+ "static-self",
 ]
 
 [[package]]
@@ -1002,6 +1009,31 @@ name = "smallvec"
 version = "1.15.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "static-self"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6635404b73efc136af3a7956e53c53d4f34b2f16c95a15c438929add0f69412"
+dependencies = [
+ "indexmap",
+ "smallvec",
+ "static-self-derive",
+]
+
+[[package]]
+name = "static-self-derive"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5268c96d4b907c558a9a52d8492522d6c7b559651a5e1d8f2d551e461b9425d5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
 
 [[package]]
 name = "strsim"

data/rust/Cargo.toml

@@ -15,7 +15,7 @@ path = "src/lib.rs"
 crate-type = ["cdylib", "staticlib", "rlib"]
 
 [dependencies]
-lightningcss = { version = "=1.0.0-alpha.72", features = ["visitor"] }
+lightningcss = { version = "=1.0.0-alpha.72", features = ["visitor", "serde"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 

data/rust/src/lib.rs

@@ -21,7 +21,7 @@ use lightningcss::bundler::{BundleErrorKind, Bundler, FileProvider};
 use lightningcss::stylesheet::{MinifyOptions, ParserOptions, PrinterOptions, StyleAttribute, StyleSheet};
 use lightningcss::visitor::Visit;
 
-use crate::options::{TransformOptions, TransformResult};
+use crate::options::{Diagnostic, ParseResult, TransformOptions, TransformResult};
 use crate::scope::Scoper;
 
 pub const VERSION: &str = env!("GEM_VERSION");
@@ -56,7 +56,7 @@ impl LightningCssResult {
   fn err(failure: Failure) -> Self {
     Self {
       value: ptr::null_mut(),
-      error: into_c_string(failure.message),
+      error: into_c_string(serde_json::to_string(&failure.diagnostic).unwrap_or(failure.diagnostic.message)),
       code: failure.code,
     }
   }
@@ -64,35 +64,35 @@ impl LightningCssResult {
 
 pub struct Failure {
   code: LightningCssErrorCode,
-  message: String,
+  diagnostic: Diagnostic,
 }
 
 impl Failure {
-  fn parse(message: impl Into<String>) -> Self {
+  fn parse(diagnostic: impl Into<Diagnostic>) -> Self {
     Self {
       code: LightningCssErrorCode::Parse,
-      message: message.into(),
+      diagnostic: diagnostic.into(),
     }
   }
 
-  fn option(message: impl Into<String>) -> Self {
+  fn option(diagnostic: impl Into<Diagnostic>) -> Self {
     Self {
       code: LightningCssErrorCode::Option,
-      message: message.into(),
+      diagnostic: diagnostic.into(),
     }
   }
 
-  fn bundle(message: impl Into<String>) -> Self {
+  fn bundle(diagnostic: impl Into<Diagnostic>) -> Self {
     Self {
       code: LightningCssErrorCode::Bundle,
-      message: message.into(),
+      diagnostic: diagnostic.into(),
     }
   }
 
-  fn internal(message: impl Into<String>) -> Self {
+  fn internal(diagnostic: impl Into<Diagnostic>) -> Self {
     Self {
       code: LightningCssErrorCode::Internal,
-      message: message.into(),
+      diagnostic: diagnostic.into(),
     }
   }
 }
@@ -125,6 +125,27 @@ unsafe fn borrow_options(pointer: *const c_char) -> Result<TransformOptions, Fai
   serde_json::from_str(json).map_err(|error| Failure::option(format!("Invalid options: {error}")))
 }
 
+fn parse_source<'i>(code: &'i str, options: &TransformOptions) -> Result<ParseResult<StyleSheet<'i>>, Failure> {
+  let collected = Arc::new(RwLock::new(Vec::new()));
+
+  let parser_options = ParserOptions {
+    filename: options.filename.clone().unwrap_or_default(),
+    error_recovery: options.error_recovery,
+    warnings: Some(collected.clone()),
+    ..ParserOptions::default()
+  };
+
+  let stylesheet =
+    StyleSheet::parse(code, parser_options).map_err(|error| Failure::parse(Diagnostic::from_error(&error)))?;
+
+  let warnings = collected
+    .read()
+    .map(|warnings| warnings.iter().map(Diagnostic::from_error).collect())
+    .unwrap_or_default();
+
+  Ok(ParseResult { stylesheet, warnings })
+}
+
 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 {
@@ -142,7 +163,8 @@ fn transform_source(code: &str, options: &TransformOptions) -> Result<TransformR
     ..ParserOptions::default()
   };
 
-  let mut stylesheet = StyleSheet::parse(code, parser_options).map_err(|error| Failure::parse(error.to_string()))?;
+  let mut stylesheet =
+    StyleSheet::parse(code, parser_options).map_err(|error| Failure::parse(Diagnostic::from_error(&error)))?;
 
   if let Some(fragment) = &options.scope {
     let mut scoper = Scoper::parse(fragment).map_err(Failure::option)?;
@@ -152,16 +174,14 @@ fn transform_source(code: &str, options: &TransformOptions) -> Result<TransformR
       .map_err(|error| Failure::internal(format!("Failed to scope stylesheet: {error:?}")))?;
   }
 
-  let targets = options.to_targets();
+  let targets = options.to_targets().map_err(Failure::option)?;
 
-  if options.minify {
-    stylesheet
-      .minify(MinifyOptions {
-        targets,
-        ..MinifyOptions::default()
-      })
-      .map_err(|error| Failure::internal(format!("Failed to minify: {error}")))?;
-  }
+  stylesheet
+    .minify(MinifyOptions {
+      targets,
+      ..MinifyOptions::default()
+    })
+    .map_err(|error| Failure::internal(format!("Failed to minify: {error}")))?;
 
   let printed = stylesheet
     .to_css(PrinterOptions {
@@ -183,7 +203,7 @@ fn transform_source(code: &str, options: &TransformOptions) -> Result<TransformR
 
   let warnings = collected
     .read()
-    .map(|warnings| warnings.iter().map(|warning| warning.to_string()).collect())
+    .map(|warnings| warnings.iter().map(Diagnostic::from_error).collect())
     .unwrap_or_default();
 
   Ok(TransformResult {
@@ -214,8 +234,8 @@ fn bundle_source(path: &str, options: &TransformOptions) -> Result<TransformResu
   let mut stylesheet = bundler
     .bundle(std::path::Path::new(path))
     .map_err(|error| match &error.kind {
-      BundleErrorKind::ParserError(_) => Failure::parse(error.to_string()),
-      _ => Failure::bundle(error.to_string()),
+      BundleErrorKind::ParserError(_) => Failure::parse(Diagnostic::from_error(&error)),
+      _ => Failure::bundle(Diagnostic::from_error(&error)),
     })?;
 
   if let Some(fragment) = &options.scope {
@@ -226,16 +246,14 @@ fn bundle_source(path: &str, options: &TransformOptions) -> Result<TransformResu
       .map_err(|error| Failure::internal(format!("Failed to scope stylesheet: {error:?}")))?;
   }
 
-  let targets = options.to_targets();
+  let targets = options.to_targets().map_err(Failure::option)?;
 
-  if options.minify {
-    stylesheet
-      .minify(MinifyOptions {
-        targets,
-        ..MinifyOptions::default()
-      })
-      .map_err(|error| Failure::internal(format!("Failed to minify: {error}")))?;
-  }
+  stylesheet
+    .minify(MinifyOptions {
+      targets,
+      ..MinifyOptions::default()
+    })
+    .map_err(|error| Failure::internal(format!("Failed to minify: {error}")))?;
 
   let printed = stylesheet
     .to_css(PrinterOptions {
@@ -254,7 +272,7 @@ fn bundle_source(path: &str, options: &TransformOptions) -> Result<TransformResu
 
   let warnings = collected
     .read()
-    .map(|warnings| warnings.iter().map(|warning| warning.to_string()).collect())
+    .map(|warnings| warnings.iter().map(Diagnostic::from_error).collect())
     .unwrap_or_default();
 
   Ok(TransformResult {
@@ -271,9 +289,10 @@ fn transform_attribute(code: &str, options: &TransformOptions) -> Result<Transfo
     ..ParserOptions::default()
   };
 
-  let mut attribute = StyleAttribute::parse(code, parser_options).map_err(|error| Failure::parse(error.to_string()))?;
+  let mut attribute =
+    StyleAttribute::parse(code, parser_options).map_err(|error| Failure::parse(Diagnostic::from_error(&error)))?;
 
-  let targets = options.to_targets();
+  let targets = options.to_targets().map_err(Failure::option)?;
 
   attribute.minify(MinifyOptions {
     targets,
@@ -295,7 +314,7 @@ fn transform_attribute(code: &str, options: &TransformOptions) -> Result<Transfo
   })
 }
 
-fn to_result(outcome: Result<TransformResult, Failure>) -> LightningCssResult {
+fn to_result(outcome: Result<impl serde::Serialize, Failure>) -> LightningCssResult {
   match outcome {
     Ok(result) => match serde_json::to_string(&result) {
       Ok(json) => LightningCssResult::ok(json),
@@ -323,6 +342,21 @@ pub unsafe extern "C" fn lightningcss_transform(
   to_result(transform_source(code, &options))
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn lightningcss_parse(code: *const c_char, options_json: *const c_char) -> LightningCssResult {
+  let code = match borrow_str(code, "code") {
+    Ok(code) => code,
+    Err(failure) => return LightningCssResult::err(failure),
+  };
+
+  let options = match borrow_options(options_json) {
+    Ok(options) => options,
+    Err(failure) => return LightningCssResult::err(failure),
+  };
+
+  to_result(parse_source(code, &options))
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn lightningcss_transform_style_attribute(
   code: *const c_char,

data/rust/src/options.rs

@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 
 use lightningcss::css_modules::{Config as CssModulesConfig, Pattern};
+use lightningcss::error::Error;
 use lightningcss::targets::{Browsers, Targets};
 use serde::{Deserialize, Serialize};
 
@@ -10,7 +11,7 @@ pub struct TransformOptions {
   pub filename: Option<String>,
   pub minify: bool,
   pub error_recovery: bool,
-  pub targets: Option<HashMap<String, u32>>,
+  pub targets: Option<HashMap<String, Version>>,
   pub css_modules: Option<CssModulesOptions>,
   pub scope: Option<String>,
 }
@@ -60,16 +61,61 @@ impl CssModulesOptions {
   }
 }
 
+#[derive(Debug, Deserialize)]
+#[serde(untagged)]
+pub enum Version {
+  Major(u32),
+  Float(f64),
+  String(String),
+}
+
+impl Version {
+  /// Encodes a version the way Lightning CSS reads it, as `major << 16 | minor << 8 | patch`.
+  fn encode(&self) -> Option<u32> {
+    match self {
+      Version::Major(major) => (*major <= 0xffff).then(|| major << 16),
+      Version::Float(float) => Self::parse(&float.to_string()),
+      Version::String(string) => Self::parse(string),
+    }
+  }
+
+  fn parse(version: &str) -> Option<u32> {
+    let mut parts = version.trim().split('.');
+
+    let major: u16 = parts.next()?.parse().ok()?;
+    let minor: u8 = parts.next().map_or(Some(0), |part| part.parse().ok())?;
+    let patch: u8 = parts.next().map_or(Some(0), |part| part.parse().ok())?;
+
+    if parts.next().is_some() {
+      return None;
+    }
+
+    Some(u32::from(major) << 16 | u32::from(minor) << 8 | u32::from(patch))
+  }
+
+  fn describe(&self) -> String {
+    match self {
+      Version::Major(major) => major.to_string(),
+      Version::Float(float) => float.to_string(),
+      Version::String(string) => format!("{string:?}"),
+    }
+  }
+}
+
 impl TransformOptions {
-  pub fn to_targets(&self) -> Targets {
+  pub fn to_targets(&self) -> Result<Targets, String> {
     let Some(versions) = &self.targets else {
-      return Targets::default();
+      return Ok(Targets::default());
     };
 
     let mut browsers = Browsers::default();
 
     for (name, version) in versions {
-      let encoded = Some(version << 16);
+      let encoded = Some(
+        version
+          .encode()
+          .ok_or_else(|| format!("Invalid version {} for {name} in targets", version.describe()))?,
+      );
 
       match name.as_str() {
         "android" => browsers.android = encoded,
@@ -85,14 +131,81 @@ impl TransformOptions {
       }
     }
 
-    Targets::from(browsers)
+    Ok(Targets::from(browsers))
   }
 }
 
+#[derive(Debug, Serialize)]
+pub struct ParseResult<T> {
+  pub stylesheet: T,
+  pub warnings: Vec<Diagnostic>,
+}
+
 #[derive(Debug, Serialize)]
 pub struct TransformResult {
   pub code: String,
   #[serde(skip_serializing_if = "Option::is_none")]
   pub exports: Option<HashMap<String, String>>,
-  pub warnings: Vec<String>,
+  pub warnings: Vec<Diagnostic>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct Diagnostic {
+  pub message: String,
+  #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
+  pub kind: Option<String>,
+  #[serde(skip_serializing_if = "Option::is_none")]
+  pub location: Option<Location>,
+}
+
+#[derive(Debug, Serialize)]
+pub struct Location {
+  pub filename: Option<String>,
+  pub line: u32,
+  pub column: u32,
+}
+
+impl Diagnostic {
+  pub fn from_error<T: std::fmt::Display + Serialize>(error: &Error<T>) -> Self {
+    Self {
+      message: error.kind.to_string(),
+      kind: serde_json::to_value(&error.kind).ok().as_ref().and_then(type_of),
+      location: error.loc.as_ref().map(|location| Location {
+        filename: (!location.filename.is_empty()).then(|| location.filename.clone()),
+        line: location.line + 1,
+        column: location.column.saturating_sub(1),
+      }),
+    }
+  }
+}
+
+impl From<String> for Diagnostic {
+  fn from(message: String) -> Self {
+    Self {
+      message,
+      kind: None,
+      location: None,
+    }
+  }
+}
+
+impl From<&str> for Diagnostic {
+  fn from(message: &str) -> Self {
+    Self::from(message.to_string())
+  }
+}
+
+fn type_of(value: &serde_json::Value) -> Option<String> {
+  match value {
+    serde_json::Value::String(name) => Some(name.clone()),
+    serde_json::Value::Object(fields) => match fields.get("type") {
+      Some(serde_json::Value::String(name)) => Some(name.clone()),
+      _ if fields.len() == 1 => fields.iter().next().map(|(name, inner)| match inner.get("type") {
+        Some(serde_json::Value::String(inner_name)) => inner_name.clone(),
+        _ => name.clone(),
+      }),
+      _ => None,
+    },
+    _ => None,
+  }
 }

data/rust/src/scope.rs

@@ -29,7 +29,8 @@ impl<'i> Scoper<'i> {
     let list = SelectorList::parse_string_with_options(fragment, ParserOptions::default()).map_err(|error| {
       format!(
         "Invalid scope selector {fragment:?} at :{}:{}",
-        error.location.line, error.location.column
+        error.location.line + 1,
+        error.location.column
       )
     })?;
 

data/sig/lightningcss/backend.rbs

@@ -6,6 +6,9 @@ module LightningCSS
       # : (String, String) -> String
       def transform: (String, String) -> String
 
+      # : (String, String) -> String
+      def parse: (String, String) -> String
+
       # : (String, String) -> String
       def transform_style_attribute: (String, String) -> String
 

data/sig/lightningcss/errors.rbs

@@ -2,6 +2,15 @@
 
 module LightningCSS
   class Error < StandardError
+    attr_reader type: String?
+
+    attr_reader location: LightningCSS::Location?
+
+    # : (String) -> instance
+    def self.from_json: (String) -> instance
+
+    # : (?String?, ?type: String?, ?location: LightningCSS::Location?) -> void
+    def initialize: (?String?, ?type: String?, ?location: LightningCSS::Location?) -> void
   end
 
   class ParseError < Error

data/sig/lightningcss/location.rbs

@@ -0,0 +1,26 @@
+# Generated from lib/lightningcss/location.rb with RBS::Inline
+
+module LightningCSS
+  class Location < Data
+    attr_reader filename(): String?
+
+    attr_reader line(): Integer
+
+    attr_reader column(): Integer
+
+    def self.new: (String? filename, Integer line, Integer column) -> instance
+                | (filename: String?, line: Integer, column: Integer) -> instance
+
+    def self.members: () -> [ :filename, :line, :column ]
+
+    def members: () -> [ :filename, :line, :column ]
+  end
+
+  class Location
+    # : (Hash[String, untyped]) -> LightningCSS::Location
+    def self.from_hash: (Hash[String, untyped]) -> LightningCSS::Location
+
+    # : () -> String
+    def to_s: () -> String
+  end
+end