tail_merge 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3aa2748d158cbcc46f8db818a6f1dbf5c0f3b210f03b48b96b178ee4e8d4c25c
-  data.tar.gz: fae3b047cf0136529135c371bae6ecdf4172bdb7f96bed1e16821a41decc9343
+  metadata.gz: ff6ca50c862b6942ab07296b4111bc84928f960883f939e153069b926b51dc38
+  data.tar.gz: 853009b24fb888e2d0af540c274541fdebbad87aded06fbab79cfcb1061f469a
 SHA512:
-  metadata.gz: ec9ef9dc0dc7f40e77fbc5ae416abdf1054a959465e5cbd22a86ecefbc6b86454ef4c416833b8c35dbc41749c5fbfa9d8b10a9e1720dba741d1ee51742d68f8d
-  data.tar.gz: c9210f053328369aa0b25a3e9f14f87a011b84c85f33f65d2a8e5962efccb7a83698cba71b824cc522469f596da2eab7c0701bd931ba0de088620cada7192914
+  metadata.gz: dc1d28edcf9b35ea2b98ba0a42821d932ad8109c21e818fa6b499fc8cdbca2db4dbe8c54540fb4d8c79dca2523f90a5883398e8736e4ef9f7693e855c956369c
+  data.tar.gz: 385cea35eb5451eb138557b3ec3312834fc4826449802f16f7f40531922ca38dc9fdd55c829fcdcc819820b7196cd10a26095ae65b5f252fc3c830d9eb380fdd

data/ext/tail_merge/src/lib.rs

@@ -1,33 +1,107 @@
-use magnus::{define_module, function, prelude::*, Error, RArray, RString, Value};
+use magnus::{
+    define_module, function, prelude::*, Error, RArray, RHash, RString, Ruby, Value,
+};
 use rustui_merge::merge::tw_merge;
 
-fn merge_tailwind_classes(arg: Value) -> Result<RString, Error> {
-    let mut class_strings = Vec::new();
-
-    if let Ok(rstring) = arg.clone().try_convert::<RString>() {
-        // If it's a string, split on spaces
-        let s = rstring.to_string()?;
-        class_strings.extend(s.split_whitespace().map(|s| s.to_string()));
-    } else if let Ok(rarray) = arg.try_convert::<RArray>() {
-        // If it's an array, process as before
-        for arg in rarray.each() {
-            let rstring: RString = arg?.try_convert()?;
-            class_strings.push(rstring.to_string()?);
-        }
-    } else {
+fn merge_tailwind_classes(args: &[Value]) -> Result<RString, Error> {
+    // ---------- 1. arity ----------------------------------------------------
+    if args.is_empty() || args.len() > 2 {
         return Err(Error::new(
-            magnus::exception::type_error(),
-            "Expected String or Array of Strings as argument",
+            magnus::exception::arg_error(),
+            "wrong number of arguments (expected 1 or 2)",
         ));
     }
 
-    let merged = tw_merge(class_strings.join(" "));
+    // ---------- 2. collect class tokens ------------------------------------
+    let mut tokens = Vec::<String>::new();
+    match args[0].clone().try_convert::<RString>() {
+        Ok(rstr) => tokens.extend(rstr.to_string()?.split_whitespace().map(str::to_owned)),
+        Err(_) => {
+            let rarray: RArray = args[0].try_convert()?;
+            for v in rarray.each() {
+                let s: RString = v?.try_convert()?;
+                tokens.push(s.to_string()?);
+            }
+        }
+    }
+
+    // ---------- 3. extract options -----------------------------------------
+    let mut prefix: Option<String> = None;
+    let mut separator: Option<String> = None;
+
+    if args.len() == 2 {
+        let rhash: RHash = args[1].try_convert()?;
+        let ruby = Ruby::get().unwrap();
+
+        if let Some(v) = rhash.get(ruby.to_symbol("prefix")) {
+            let s: RString = v.try_convert()?;
+            prefix = Some(s.to_string()?);
+        }
+        if let Some(v) = rhash.get(ruby.to_symbol("separator")) {
+            let s: RString = v.try_convert()?;
+            separator = Some(s.to_string()?);
+        }
+    }
+
+    // ---------- 4. merge ----------------------------------------------------
+    let merged = if let Some(pref) = prefix {
+        // split based on whether the last segment starts with the prefix
+        let mut with_pref = Vec::new();
+        let mut without_pref = Vec::new();
+
+        for t in tokens {
+            let base = t.rsplit_once(':').map(|(_, b)| b).unwrap_or(&t);
+            if base.starts_with(&pref) {
+                // strip prefix after variant(s)
+                let stripped = if let Some((v, b)) = t.rsplit_once(':') {
+                    format!("{}:{}", v, &b[pref.len()..])
+                } else {
+                    (&t[pref.len()..]).to_owned()
+                };
+                with_pref.push(stripped);
+            } else {
+                without_pref.push(t);
+            }
+        }
+
+        let mut out = Vec::new();
+        if !without_pref.is_empty() {
+            out.extend(
+                tw_merge(without_pref.join(" "))
+                    .split_whitespace()
+                    .map(str::to_owned),
+            );
+        }
+        if !with_pref.is_empty() {
+            out.extend(
+                tw_merge(with_pref.join(" "))
+                    .split_whitespace()
+                    .map(|s| {
+                        // re-attach prefix
+                        if let Some((v, b)) = s.rsplit_once(':') {
+                            format!("{}:{}{}", v, &pref, b)
+                        } else {
+                            format!("{}{}", pref, s)
+                        }
+                    }),
+            );
+        }
+        out.join(" ")
+    } else if separator.is_some() {
+        // at the moment we can't apply per-call separators without global state;
+        // fall back to the default behaviour.
+        tw_merge(tokens.join(" "))
+    } else {
+        tw_merge(tokens.join(" "))
+    };
+
     Ok(RString::new(&merged))
 }
 
 #[magnus::init]
 fn init() -> Result<(), Error> {
     let module = define_module("TailMerge")?;
-    module.define_singleton_method("merge", function!(merge_tailwind_classes, 1))?;
+    // -1 = variable arity (positional + kw-hash)
+    module.define_singleton_method("merge", function!(merge_tailwind_classes, -1))?;
     Ok(())
 }

data/lib/tail_merge/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tail_merge
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Achilleas Buisman