tail_merge 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3aa2748d158cbcc46f8db818a6f1dbf5c0f3b210f03b48b96b178ee4e8d4c25c
-  data.tar.gz: fae3b047cf0136529135c371bae6ecdf4172bdb7f96bed1e16821a41decc9343
+  metadata.gz: '09136ec0a7747e58715fc95aae08f3c81599247202a152bc3b21c85217b5dbad'
+  data.tar.gz: b4313ed6f949a48149d1e417e88c84bd026dd9791197f68f0137c2217e5798fb
 SHA512:
-  metadata.gz: ec9ef9dc0dc7f40e77fbc5ae416abdf1054a959465e5cbd22a86ecefbc6b86454ef4c416833b8c35dbc41749c5fbfa9d8b10a9e1720dba741d1ee51742d68f8d
-  data.tar.gz: c9210f053328369aa0b25a3e9f14f87a011b84c85f33f65d2a8e5962efccb7a83698cba71b824cc522469f596da2eab7c0701bd931ba0de088620cada7192914
+  metadata.gz: 8a797eafd289cc37273f8ebf323241f6245f9a90337dc2c9b9841d279ec7eac957b492ed974b4a4c9bc824485dd057722fc2191ff04d9bddeff6ec3b50b85f43
+  data.tar.gz: 7e52a4c5a9b2d763228aab6930895742a2f2dddfbbb2581fb6d8b31dfd719bcb85b75d86a43976f45b65d22dadd6527187a771744a432d808fe24c241c11694a

data/ext/tail_merge/src/lib.rs

@@ -1,33 +1,126 @@
-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();
+fn merge_tailwind_classes(args: &[Value]) -> Result<RString, Error> {
+    // ---------- 1. arity ----------------------------------------------------
+    if args.is_empty() || args.len() > 2 {
+        return Err(Error::new(
+            magnus::exception::arg_error(),
+            "wrong number of arguments (expected 1 or 2)",
+        ));
+    }
+
+    // ---------- 2. collect class tokens ------------------------------------
+    let mut tokens = Vec::<String>::new();
+    let is_string_input = matches!(args[0].clone().try_convert::<RString>(), Ok(_));
+    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()?);
+            }
+        }
+    }
 
-    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()?);
+    // Early returns for simple cases
+    if is_string_input {
+        let rstr: RString = args[0].clone().try_convert()?;
+        let s = rstr.to_string()?;
+        if !s.contains(' ') {
+            // Single class string, return as-is
+            return Ok(RString::new(&s));
         }
     } else {
-        return Err(Error::new(
-            magnus::exception::type_error(),
-            "Expected String or Array of Strings as argument",
-        ));
+        // Array input
+        if tokens.is_empty() {
+            return Ok(RString::new(""));
+        }
+        if tokens.len() == 1 {
+            return Ok(RString::new(&tokens[0]));
+        }
     }
 
-    let merged = tw_merge(class_strings.join(" "));
+    // ---------- 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.3.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.3.0
 platform: ruby
 authors:
 - Achilleas Buisman