lightningcss 0.1.0-arm-linux-gnu

data/rust/Cargo.toml

@@ -0,0 +1,24 @@
+[workspace]
+
+[package]
+name = "lightningcss-ffi"
+version = "0.1.0"
+edition = "2021"
+authors = ["Marco Roth <marco.roth@intergga.ch>"]
+description = "C FFI bindings for Lightning CSS, used by the lightningcss gem"
+license = "MIT"
+repository = "https://github.com/marcoroth/lightningcss-ruby"
+publish = false
+
+[lib]
+name = "lightningcss_ffi"
+path = "src/lib.rs"
+crate-type = ["cdylib", "staticlib", "rlib"]
+
+[dependencies]
+lightningcss = { version = "1.0.0-alpha.68", features = ["visitor"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+
+[build-dependencies]
+cbindgen = "0.28"

data/rust/build.rs

@@ -0,0 +1,15 @@
+use std::env;
+use std::path::PathBuf;
+
+fn main() {
+  let crate_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
+  let header_path = PathBuf::from(&crate_dir).join("../ext/lightningcss/include/lightningcss.h");
+
+  if let Ok(bindings) = cbindgen::generate(&crate_dir) {
+    if let Some(parent) = header_path.parent() {
+      let _ = std::fs::create_dir_all(parent);
+    }
+
+    bindings.write_to_file(&header_path);
+  }
+}

data/rust/cbindgen.toml

@@ -0,0 +1,23 @@
+language = "C"
+header = """/* Generated by cbindgen — do not edit manually */
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <stddef.h>"""
+include_guard = "LIGHTNINGCSS_H"
+no_includes = true
+
+[export]
+include = [
+  "LightningCssResult",
+]
+
+[enum]
+rename_variants = "ScreamingSnakeCase"
+prefix_with_name = true
+
+[fn]
+sort_by = "None"
+
+[parse]
+parse_deps = false

data/rust/rustfmt.toml

@@ -0,0 +1,3 @@
+tab_spaces = 2
+max_width = 120
+edition = "2021"

data/rust/src/lib.rs

@@ -0,0 +1,308 @@
+//! C FFI bindings for Lightning CSS.
+//!
+//! # Safety
+//!
+//! Every function here requires that pointer arguments are valid, NUL-terminated C strings unless
+//! documented as nullable. Returned pointers are owned by the caller and must be released with
+//! `lightningcss_string_free` or `lightningcss_result_free`.
+
+#![allow(clippy::missing_safety_doc)]
+
+mod options;
+mod scope;
+
+use std::collections::HashMap;
+use std::ffi::{CStr, CString};
+use std::os::raw::c_char;
+use std::ptr;
+use std::sync::{Arc, RwLock};
+
+use lightningcss::bundler::{Bundler, FileProvider};
+use lightningcss::stylesheet::{MinifyOptions, ParserOptions, PrinterOptions, StyleAttribute, StyleSheet};
+use lightningcss::visitor::Visit;
+
+use crate::options::{TransformOptions, TransformResult};
+use crate::scope::Scoper;
+
+pub const VERSION: &str = env!("CARGO_PKG_VERSION");
+
+#[repr(C)]
+pub struct LightningCssResult {
+  pub value: *mut c_char,
+  pub error: *mut c_char,
+}
+
+impl LightningCssResult {
+  fn ok(value: String) -> Self {
+    Self {
+      value: into_c_string(value),
+      error: ptr::null_mut(),
+    }
+  }
+
+  fn err(message: impl AsRef<str>) -> Self {
+    Self {
+      value: ptr::null_mut(),
+      error: into_c_string(message.as_ref()),
+    }
+  }
+}
+
+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> {
+  if pointer.is_null() {
+    return Err(format!("{label} is null"));
+  }
+
+  CStr::from_ptr(pointer)
+    .to_str()
+    .map_err(|error| format!("Invalid UTF-8 in {label}: {error}"))
+}
+
+unsafe fn borrow_options(pointer: *const c_char) -> Result<TransformOptions, String> {
+  if pointer.is_null() {
+    return Ok(TransformOptions::default());
+  }
+
+  let json = borrow_str(pointer, "options")?;
+
+  if json.trim().is_empty() {
+    return Ok(TransformOptions::default());
+  }
+
+  serde_json::from_str(json).map_err(|error| format!("Invalid options: {error}"))
+}
+
+fn transform_source(code: &str, options: &TransformOptions) -> Result<TransformResult, String> {
+  let filename = options.filename.clone().unwrap_or_default();
+  let css_modules = match &options.css_modules {
+    Some(modules) => Some(modules.to_config()?),
+    None => None,
+  };
+
+  let collected = Arc::new(RwLock::new(Vec::new()));
+
+  let parser_options = ParserOptions {
+    filename: filename.clone(),
+    css_modules,
+    error_recovery: options.error_recovery,
+    warnings: Some(collected.clone()),
+    ..ParserOptions::default()
+  };
+
+  let mut stylesheet = StyleSheet::parse(code, parser_options).map_err(|error| error.to_string())?;
+
+  if let Some(fragment) = &options.scope {
+    let mut scoper = Scoper::parse(fragment)?;
+
+    stylesheet
+      .visit(&mut scoper)
+      .map_err(|error| format!("Failed to scope stylesheet: {error:?}"))?;
+  }
+
+  let targets = options.to_targets();
+
+  if options.minify {
+    stylesheet
+      .minify(MinifyOptions {
+        targets,
+        ..MinifyOptions::default()
+      })
+      .map_err(|error| format!("Failed to minify: {error}"))?;
+  }
+
+  let printed = stylesheet
+    .to_css(PrinterOptions {
+      minify: options.minify,
+      source_map: None,
+      project_root: None,
+      targets,
+      analyze_dependencies: None,
+      pseudo_classes: None,
+    })
+    .map_err(|error| 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,
+    warnings,
+  })
+}
+
+fn bundle_source(path: &str, options: &TransformOptions) -> Result<TransformResult, String> {
+  let css_modules = match &options.css_modules {
+    Some(modules) => Some(modules.to_config()?),
+    None => None,
+  };
+
+  let parser_options = ParserOptions {
+    css_modules,
+    error_recovery: options.error_recovery,
+    ..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())?;
+
+  if let Some(fragment) = &options.scope {
+    let mut scoper = Scoper::parse(fragment)?;
+
+    stylesheet
+      .visit(&mut scoper)
+      .map_err(|error| format!("Failed to scope stylesheet: {error:?}"))?;
+  }
+
+  let targets = options.to_targets();
+
+  if options.minify {
+    stylesheet
+      .minify(MinifyOptions {
+        targets,
+        ..MinifyOptions::default()
+      })
+      .map_err(|error| format!("Failed to minify: {error}"))?;
+  }
+
+  let printed = stylesheet
+    .to_css(PrinterOptions {
+      minify: options.minify,
+      targets,
+      ..PrinterOptions::default()
+    })
+    .map_err(|error| format!("Failed to print: {error}"))?;
+
+  Ok(TransformResult {
+    code: printed.code,
+    exports: None,
+    warnings: Vec::new(),
+  })
+}
+
+fn transform_attribute(code: &str, options: &TransformOptions) -> Result<TransformResult, String> {
+  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 targets = options.to_targets();
+
+  attribute.minify(MinifyOptions {
+    targets,
+    ..MinifyOptions::default()
+  });
+
+  let printed = attribute
+    .to_css(PrinterOptions {
+      minify: options.minify,
+      targets,
+      ..PrinterOptions::default()
+    })
+    .map_err(|error| format!("Failed to print: {error}"))?;
+
+  Ok(TransformResult {
+    code: printed.code,
+    exports: None,
+    warnings: Vec::new(),
+  })
+}
+
+fn to_result(outcome: Result<TransformResult, String>) -> 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(message) => LightningCssResult::err(message),
+  }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn lightningcss_transform(
+  code: *const c_char,
+  options_json: *const c_char,
+) -> LightningCssResult {
+  let code = match borrow_str(code, "code") {
+    Ok(code) => code,
+    Err(message) => return LightningCssResult::err(message),
+  };
+
+  let options = match borrow_options(options_json) {
+    Ok(options) => options,
+    Err(message) => return LightningCssResult::err(message),
+  };
+
+  to_result(transform_source(code, &options))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn lightningcss_transform_style_attribute(
+  code: *const c_char,
+  options_json: *const c_char,
+) -> LightningCssResult {
+  let code = match borrow_str(code, "code") {
+    Ok(code) => code,
+    Err(message) => return LightningCssResult::err(message),
+  };
+
+  let options = match borrow_options(options_json) {
+    Ok(options) => options,
+    Err(message) => return LightningCssResult::err(message),
+  };
+
+  to_result(transform_attribute(code, &options))
+}
+
+#[no_mangle]
+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),
+  };
+
+  let options = match borrow_options(options_json) {
+    Ok(options) => options,
+    Err(message) => return LightningCssResult::err(message),
+  };
+
+  to_result(bundle_source(path, &options))
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn lightningcss_version() -> *mut c_char {
+  into_c_string(VERSION)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn lightningcss_string_free(value: *mut c_char) {
+  if !value.is_null() {
+    drop(CString::from_raw(value));
+  }
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn lightningcss_result_free(result: LightningCssResult) {
+  lightningcss_string_free(result.value);
+  lightningcss_string_free(result.error);
+}

data/rust/src/options.rs

@@ -0,0 +1,98 @@
+use std::collections::HashMap;
+
+use lightningcss::css_modules::{Config as CssModulesConfig, Pattern};
+use lightningcss::targets::{Browsers, Targets};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Default, Deserialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct TransformOptions {
+  pub filename: Option<String>,
+  pub minify: bool,
+  pub error_recovery: bool,
+  pub targets: Option<HashMap<String, u32>>,
+  pub css_modules: Option<CssModulesOptions>,
+  pub scope: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(default, deny_unknown_fields)]
+pub struct CssModulesOptions {
+  pub pattern: Option<String>,
+  pub dashed_idents: bool,
+  pub animation: bool,
+  pub grid: bool,
+  pub container: bool,
+  pub custom_idents: bool,
+  pub pure: bool,
+}
+
+impl Default for CssModulesOptions {
+  fn default() -> Self {
+    Self {
+      pattern: None,
+      dashed_idents: false,
+      animation: true,
+      grid: true,
+      container: true,
+      custom_idents: true,
+      pure: false,
+    }
+  }
+}
+
+impl CssModulesOptions {
+  pub fn to_config(&self) -> Result<CssModulesConfig, String> {
+    let pattern = match &self.pattern {
+      Some(pattern) => Pattern::parse(pattern).map_err(|_| format!("Invalid CSS modules pattern {pattern:?}"))?,
+      None => Pattern::default(),
+    };
+
+    Ok(CssModulesConfig {
+      pattern,
+      dashed_idents: self.dashed_idents,
+      animation: self.animation,
+      grid: self.grid,
+      container: self.container,
+      custom_idents: self.custom_idents,
+      pure: self.pure,
+    })
+  }
+}
+
+impl TransformOptions {
+  pub fn to_targets(&self) -> Targets {
+    let Some(versions) = &self.targets else {
+      return Targets::default();
+    };
+
+    let mut browsers = Browsers::default();
+
+    for (name, version) in versions {
+      let encoded = Some(version << 16);
+
+      match name.as_str() {
+        "android" => browsers.android = encoded,
+        "chrome" => browsers.chrome = encoded,
+        "edge" => browsers.edge = encoded,
+        "firefox" => browsers.firefox = encoded,
+        "ie" => browsers.ie = encoded,
+        "ios_saf" | "ios" => browsers.ios_saf = encoded,
+        "opera" => browsers.opera = encoded,
+        "safari" => browsers.safari = encoded,
+        "samsung" => browsers.samsung = encoded,
+        _ => {}
+      }
+    }
+
+    Targets::from(browsers)
+  }
+}
+
+#[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>,
+}

data/rust/src/scope.rs

@@ -0,0 +1,63 @@
+//! Confining a stylesheet's selectors to a scope.
+//!
+//! The scope is given as a selector fragment, which is appended to what each rule already matches.
+//! `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
+//!
+//! A fragment is anything that parses as one compound selector, so an attribute and a `:where()`
+//! carrying its own alternatives are both expressible.
+
+use std::convert::Infallible;
+
+use lightningcss::selector::{Component, Selector, SelectorList};
+use lightningcss::stylesheet::ParserOptions;
+use lightningcss::traits::ParseWithOptions;
+use lightningcss::visit_types;
+use lightningcss::visitor::{VisitTypes, Visitor};
+
+pub struct Scoper<'i> {
+  components: Vec<Component<'i>>,
+}
+
+impl<'i> Scoper<'i> {
+  pub fn parse(fragment: &'i str) -> Result<Self, String> {
+    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
+      )
+    })?;
+
+    let selector = list
+      .0
+      .first()
+      .ok_or_else(|| format!("Scope selector {fragment:?} is empty"))?;
+
+    if list.0.len() > 1 {
+      return Err(format!("Scope selector {fragment:?} has to be a single selector"));
+    }
+
+    Ok(Self {
+      components: selector.iter_raw_match_order().cloned().collect(),
+    })
+  }
+}
+
+impl<'i> Visitor<'i> for Scoper<'i> {
+  type Error = Infallible;
+
+  fn visit_types(&self) -> VisitTypes {
+    visit_types!(SELECTORS)
+  }
+
+  fn visit_selector(&mut self, selector: &mut Selector<'i>) -> Result<(), Self::Error> {
+    for component in &self.components {
+      selector.append(component.clone());
+    }
+
+    Ok(())
+  }
+}

data/sig/lightningcss/backend.rbs

@@ -0,0 +1,26 @@
+# Generated from lib/lightningcss/backend.rb with RBS::Inline
+
+module LightningCSS
+  module Backend
+    module Unavailable
+      # : (String, String) -> String
+      def transform: (String, String) -> String
+
+      # : (String, String) -> String
+      def transform_style_attribute: (String, String) -> String
+
+      # : (String, String) -> String
+      def bundle: (String, String) -> String
+
+      # : () -> String
+      def version: () -> String
+
+      private
+
+      # : (Symbol?) -> bot
+      def unavailable: (Symbol?) -> bot
+    end
+
+    extend Unavailable
+  end
+end

data/sig/lightningcss/errors.rbs

@@ -0,0 +1,15 @@
+# Generated from lib/lightningcss/errors.rb with RBS::Inline
+
+module LightningCSS
+  class Error < StandardError
+  end
+
+  class ParseError < Error
+  end
+
+  class OptionError < Error
+  end
+
+  class BundleError < Error
+  end
+end

data/sig/lightningcss/options.rbs

@@ -0,0 +1,38 @@
+# Generated from lib/lightningcss/options.rb with RBS::Inline
+
+module LightningCSS
+  # The options a call was given, on their way to the native library.
+  #
+  # Lightning CSS reads them as JSON, so this is where a Ruby hash becomes one, and where an option
+  # nobody knows is refused. Refusing early is the point: an option the native side does not read
+  # would otherwise be accepted and quietly do nothing.
+  #
+  #     LightningCSS::Options.new(minify: true).to_json  #=> "{\"minify\":true}"
+  class Options
+    KNOWN: Array[Symbol]
+
+    STYLE_ATTRIBUTE: 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
+
+    # : (?allowed: Array[Symbol], ?subject: String, **untyped) -> void
+    def initialize: (?allowed: Array[Symbol], ?subject: String, **untyped) -> void
+
+    # : (?untyped) -> String
+    def to_json: (?untyped) -> String
+
+    # : () -> String
+    def inspect: () -> String
+
+    private
+
+    # : (Array[Symbol], Array[Symbol], String) -> void
+    def validate!: (Array[Symbol], Array[Symbol], String) -> void
+
+    # : (Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
+    def normalize: (Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
+  end
+end

data/sig/lightningcss/result.rbs

@@ -0,0 +1,34 @@
+# Generated from lib/lightningcss/result.rb with RBS::Inline
+
+module LightningCSS
+  # What a transform produced.
+  #
+  # `exports` is only filled in when the stylesheet was compiled as a CSS module, and maps every
+  # name as it was written to the name it was compiled to. A transform that was not asked for a
+  # CSS module has none, and neither does a style attribute, which has no names to compile.
+  #
+  # `warnings` holds what Lightning CSS understood well enough to keep but not well enough to act
+  # on, which is everything it would otherwise have dropped without saying so.
+  class Result
+    attr_reader code: String
+
+    attr_reader exports: Hash[String, String]?
+
+    attr_reader warnings: Array[String]
+
+    # : (String) -> LightningCSS::Result
+    def self.from_json: (String) -> LightningCSS::Result
+
+    # : (code: String, warnings: Array[String], ?exports: Hash[String, String]?) -> void
+    def initialize: (code: String, warnings: Array[String], ?exports: Hash[String, String]?) -> void
+
+    # : () -> bool
+    def warnings?: () -> bool
+
+    # : () -> String
+    def to_s: () -> String
+
+    # : () -> String
+    def inspect: () -> String
+  end
+end

data/sig/lightningcss/transformer.rbs

@@ -0,0 +1,39 @@
+# Generated from lib/lightningcss/transformer.rb with RBS::Inline
+
+module LightningCSS
+  # A set of options to transform many stylesheets with.
+  #
+  #     transformer = LightningCSS::Transformer.new(minify: true, targets: { chrome: 100 })
+  #
+  #     transformer.transform(".a { color: red }").code
+  #     transformer.transform(".b { color: red }", scope: "[data-scope-abc]").code
+  #
+  # Options given to a call are merged over the ones it was built with, so the ones that belong to
+  # the project are written once and the ones that belong to a single stylesheet travel with it.
+  class Transformer
+    attr_reader options: Hash[Symbol, untyped]
+
+    # : (?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> void
+    def initialize: (?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> void
+
+    # : (String, ?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
+    def transform: (String, ?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Result
+
+    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, ?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
+
+    # : (String, ?filename: String?, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> String
+    def minify: (String, ?filename: String?, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> String
+
+    # : (?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Transformer
+    def with: (?filename: String?, ?minify: bool, ?error_recovery: bool, ?targets: browsers?, ?css_modules: css_modules?, ?scope: String?) -> LightningCSS::Transformer
+
+    # : () -> String
+    def inspect: () -> String
+  end
+end