klenod-plugin-css 0.0.1

data/ext/native/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "native"
+version = "0.0.1"
+edition = "2021"
+
+[lib]
+name = "native"
+crate-type = ["cdylib"]
+
+[dependencies]
+base64 = "0.22.1"
+cssparser = "0.37.0"
+lightningcss = { version = "1.0.0-alpha.70", features = ["serde", "visitor", "sourcemap"] }
+magnus = "0.8.2"
+parcel_sourcemap = { version = "2.1.1", features = ["json"] }
+serde_json = "1.0.149"
+sha2 = "0.10.9"

data/ext/native/extconf.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "mkmf"
+require "rb_sys/mkmf"
+
+create_rust_makefile("klenod/plugin/css/native")

data/ext/native/src/lib.rs

@@ -0,0 +1,346 @@
+use lightningcss::dependencies::DependencyOptions;
+use lightningcss::{
+    properties::{css_modules::Specifier, custom::Variable},
+    selector::{Component, Selector},
+    stylesheet::{MinifyOptions, ParserOptions, PrinterOptions, StyleSheet},
+    values::ident::DashedIdent,
+    visitor::{Visit, VisitTypes, Visitor},
+};
+use magnus::{
+    exception::ExceptionClass, function, gc::register_mark_object, prelude::*, value::Lazy, Error,
+    RHash, RModule, Ruby, TryConvert,
+};
+use parcel_sourcemap::SourceMap;
+use std::{collections::HashMap, convert::Infallible};
+
+static PARSE_ERROR: Lazy<ExceptionClass> = Lazy::new(|ruby| {
+    let ex = ruby
+        .class_object()
+        .const_get::<_, RModule>("Klenod")
+        .unwrap()
+        .const_get::<_, RModule>("Build")
+        .unwrap()
+        .const_get::<_, RModule>("Plugins")
+        .unwrap()
+        .const_get::<_, RModule>("CSSPlugin")
+        .unwrap()
+        .const_get("ParseError")
+        .unwrap();
+    register_mark_object(ex);
+    ex
+});
+
+#[derive(Clone)]
+struct TransformOptions {
+    component: String,
+    hash: String,
+    transform_names: bool,
+    class_pattern: String,
+    tag_pattern: String,
+    variable_pattern: String,
+    local_css_variables: bool,
+}
+
+struct TransformNamesVisitor<'a> {
+    options: TransformOptions,
+    classes: &'a mut HashMap<String, String>,
+    elements: &'a mut HashMap<String, String>,
+    variables: &'a mut HashMap<String, String>,
+}
+
+impl<'a, 'i> Visitor<'i> for TransformNamesVisitor<'a> {
+    type Error = Infallible;
+
+    fn visit_types(&self) -> VisitTypes {
+        VisitTypes::RULES | VisitTypes::DASHED_IDENTS | VisitTypes::VARIABLES
+    }
+
+    fn visit_selector(&mut self, selector: &mut Selector<'i>) -> Result<(), Self::Error> {
+        for component in selector.iter_mut_raw_match_order() {
+            match component {
+                Component::Class(class_name) => {
+                    let original = class_name.to_string();
+                    let formatted = format_selector(
+                        &self.options.class_pattern,
+                        &self.options.component,
+                        &original,
+                        &self.options.hash,
+                    );
+                    self.classes.insert(original, formatted.clone());
+                    if self.options.transform_names {
+                        *component = Component::Class(formatted.into());
+                    }
+                }
+                Component::LocalName(local_name) => {
+                    let original = local_name.name.to_string();
+                    let formatted = format_selector(
+                        &self.options.tag_pattern,
+                        &self.options.component,
+                        &original,
+                        &self.options.hash,
+                    );
+                    self.elements.insert(original, formatted.clone());
+                    if self.options.transform_names {
+                        *component = Component::Class(formatted.into());
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        Ok(())
+    }
+
+    fn visit_dashed_ident(&mut self, ident: &mut DashedIdent) -> Result<(), Self::Error> {
+        if !self.options.local_css_variables {
+            return Ok(());
+        }
+
+        let original = ident.0.to_string();
+        let formatted = format_variable(
+            &self.options.variable_pattern,
+            &self.options.component,
+            &original,
+            &self.options.hash,
+        );
+        self.variables.insert(original, formatted.clone());
+        if self.options.transform_names {
+            ident.0 = formatted.into();
+        }
+
+        Ok(())
+    }
+
+    fn visit_variable(&mut self, variable: &mut Variable) -> Result<(), Self::Error> {
+        if !matches!(
+            variable.name.from,
+            Some(Specifier::File(_)) | Some(Specifier::Global)
+        ) {
+            variable.visit_children(self)?;
+        } else if let Some(fallback) = &mut variable.fallback {
+            fallback.visit(self)?;
+        }
+
+        Ok(())
+    }
+}
+
+fn transform_native(
+    ruby: &Ruby,
+    source: String,
+    filename: String,
+    options: RHash,
+) -> Result<RHash, Error> {
+    let minify = hash_fetch_bool(ruby, options, "minify", true)?;
+    let transform_names = hash_fetch_bool(ruby, options, "transform_names", true)?;
+    let local_css_variables = hash_fetch_bool(ruby, options, "local_css_variables", false)?;
+    let class_pattern =
+        hash_fetch_string(ruby, options, "class_pattern", "[component].[local]?[hash]")?;
+    let tag_pattern =
+        hash_fetch_string(ruby, options, "tag_pattern", "[component]_[local]?[hash]")?;
+    let variable_pattern = hash_fetch_string(
+        ruby,
+        options,
+        "variable_pattern",
+        "[component]-[local]?[hash]",
+    )?;
+    let mut stylesheet = parse_stylesheet(ruby, &filename, &source, local_css_variables)?;
+    let mut classes = HashMap::new();
+    let mut elements = HashMap::new();
+    let mut variables = HashMap::new();
+    let selector_options = TransformOptions {
+        component: component_name(&filename),
+        hash: hash(&source),
+        transform_names,
+        class_pattern,
+        tag_pattern,
+        variable_pattern,
+        local_css_variables,
+    };
+
+    let _ = stylesheet.visit(&mut TransformNamesVisitor {
+        options: selector_options,
+        classes: &mut classes,
+        elements: &mut elements,
+        variables: &mut variables,
+    });
+
+    let mut source_map = SourceMap::new("/");
+    source_map.add_source(&filename);
+    source_map.set_source_content(0, &source).unwrap();
+
+    if minify {
+        stylesheet.minify(MinifyOptions::default()).unwrap();
+    }
+
+    let result = stylesheet
+        .to_css(PrinterOptions {
+            analyze_dependencies: Some(DependencyOptions::default()),
+            minify,
+            source_map: Some(&mut source_map),
+            ..PrinterOptions::default()
+        })
+        .unwrap();
+
+    let hash = ruby.hash_new();
+    hash.aset("code", result.code)?;
+    hash.aset("classes", string_map_to_hash(ruby, classes)?)?;
+    hash.aset("elements", string_map_to_hash(ruby, elements)?)?;
+    hash.aset(
+        "serialized_variables",
+        serialized_variable_map_to_hash(ruby, &variables)?,
+    )?;
+    hash.aset("variables", string_map_to_hash(ruby, variables)?)?;
+    hash.aset("source_map", source_map.to_json(None).ok())?;
+    hash.aset(
+        "dependencies",
+        serde_json::from_str::<serde_json::Value>(
+            &serde_json::to_string(&result.dependencies.unwrap()).unwrap(),
+        )
+        .unwrap()
+        .to_string(),
+    )?;
+    hash.aset(
+        "exports",
+        serde_json::from_str::<serde_json::Value>(
+            &serde_json::to_string(&result.exports.unwrap()).unwrap(),
+        )
+        .unwrap()
+        .to_string(),
+    )?;
+    hash.aset(
+        "references",
+        serde_json::from_str::<serde_json::Value>(
+            &serde_json::to_string(&result.references.unwrap_or_default()).unwrap(),
+        )
+        .unwrap()
+        .to_string(),
+    )?;
+    Ok(hash)
+}
+
+fn minify_native(ruby: &Ruby, source: String, filename: String) -> Result<String, Error> {
+    let mut stylesheet = parse_stylesheet(ruby, &filename, &source, false)?;
+    stylesheet.minify(MinifyOptions::default()).unwrap();
+
+    Ok(stylesheet
+        .to_css(PrinterOptions {
+            analyze_dependencies: Some(DependencyOptions::default()),
+            minify: true,
+            ..PrinterOptions::default()
+        })
+        .unwrap()
+        .code)
+}
+
+fn serialize_native(ruby: &Ruby, source: String, filename: String) -> Result<String, Error> {
+    let stylesheet = parse_stylesheet(ruby, &filename, &source, false)?;
+    Ok(serde_json::to_string(&stylesheet).unwrap())
+}
+
+fn parse_stylesheet<'i>(
+    ruby: &Ruby,
+    filename: &str,
+    source: &'i str,
+    local_css_variables: bool,
+) -> Result<StyleSheet<'i>, Error> {
+    StyleSheet::parse(
+        source,
+        ParserOptions {
+            filename: filename.to_string(),
+            css_modules: Some(lightningcss::css_modules::Config {
+                pattern: lightningcss::css_modules::Pattern::parse("[local]").unwrap(),
+                dashed_idents: local_css_variables,
+                animation: false,
+                grid: false,
+                container: false,
+                custom_idents: false,
+                pure: false,
+            }),
+            ..ParserOptions::default()
+        },
+    )
+    .map_err(|error| Error::new(ruby.get_inner(&PARSE_ERROR), error.to_string()))
+}
+
+fn hash_fetch_bool(_ruby: &Ruby, hash: RHash, key: &str, default: bool) -> Result<bool, Error> {
+    match hash.get(key) {
+        Some(value) => bool::try_convert(value),
+        None => Ok(default),
+    }
+}
+
+fn hash_fetch_string(_ruby: &Ruby, hash: RHash, key: &str, default: &str) -> Result<String, Error> {
+    match hash.get(key) {
+        Some(value) => String::try_convert(value),
+        None => Ok(default.to_string()),
+    }
+}
+
+fn string_map_to_hash(ruby: &Ruby, map: HashMap<String, String>) -> Result<RHash, Error> {
+    let hash = ruby.hash_new();
+    for (key, value) in map {
+        hash.aset(key, value)?;
+    }
+    Ok(hash)
+}
+
+fn serialized_variable_map_to_hash(
+    ruby: &Ruby,
+    map: &HashMap<String, String>,
+) -> Result<RHash, Error> {
+    let hash = ruby.hash_new();
+    for (key, value) in map {
+        let mut serialized = String::new();
+        cssparser::serialize_identifier(value, &mut serialized).unwrap();
+        hash.aset(key.clone(), serialized)?;
+    }
+    Ok(hash)
+}
+
+fn component_name(filename: &str) -> String {
+    std::path::Path::new(filename)
+        .with_extension("")
+        .display()
+        .to_string()
+}
+
+fn format_selector(pattern: &str, component: &str, local: &str, hash: &str) -> String {
+    pattern
+        .replace("[component]", component)
+        .replace("[local]", local)
+        .replace("[hash]", hash)
+}
+
+fn format_variable(pattern: &str, component: &str, local: &str, hash: &str) -> String {
+    format!(
+        "--{}",
+        format_selector(pattern, component, local.trim_start_matches("--"), hash)
+    )
+}
+
+fn hash(source: &str) -> String {
+    use base64::{engine::general_purpose, Engine as _};
+    use sha2::{Digest, Sha256};
+
+    let mut hasher = Sha256::new();
+    hasher.update(source);
+    general_purpose::URL_SAFE_NO_PAD
+        .encode(hasher.finalize())
+        .get(0..8)
+        .unwrap()
+        .to_string()
+}
+
+#[magnus::init]
+fn init(ruby: &Ruby) -> Result<(), Error> {
+    let klenod = ruby.define_module("Klenod")?;
+    let build = klenod.define_module("Build")?;
+    let plugins = build.define_module("Plugins")?;
+    let css_plugin = plugins.define_module("CSSPlugin")?;
+    let native = css_plugin.define_module("Native")?;
+    native.define_singleton_method("transform_native", function!(transform_native, 3))?;
+    native.define_singleton_method("minify_native", function!(minify_native, 2))?;
+    native.define_singleton_method("serialize_native", function!(serialize_native, 2))?;
+    Ok(())
+}