retail.sku-generate

pub fn generate_sku(prefix: &str, attributes: &[String], segment_length: i64) -> String

fune!(retail.sku-generate@^1);  // then call generate_sku(…)

use super::funejson::Value;  ← the fune runtime: the JSON value the test vectors use; fune build keeps it only where a signature takes one

// Keep ASCII letters and digits only, then uppercase. Filtering first matters:
// "ß".to_uppercase() is "SS", which would make the SKU depend on how each
// language's Unicode tables treat one letter.
fn clean(part: &str) -> String {
    part.chars()
        .filter(|c| c.is_ascii_alphanumeric())
        .map(|c| c.to_ascii_uppercase())
        .collect()
}

/// A deterministic SKU: the cleaned prefix and attributes, joined by hyphens.
/// Each attribute is cut to `segment_length` characters (0 keeps it whole).
///
/// # Panics
/// Panics on a negative segment length, no attributes, or a part with no
/// letters or digits.
pub fn generate_sku(prefix: &str, attributes: &[String], segment_length: i64) -> String {
    if segment_length < 0 {
        panic!("segmentLength must be 0 or more, received {}", segment_length);
    }
    if attributes.is_empty() {
        panic!("a SKU needs at least one attribute");
    }
    let mut parts: Vec<String> = Vec::new();
    if !prefix.is_empty() {
        let cleaned = clean(prefix);
        if cleaned.is_empty() {
            panic!("prefix (\"{}\") has no letters or digits", prefix);
        }
        parts.push(cleaned);
    }
    for (index, attribute) in attributes.iter().enumerate() {
        let cleaned = clean(attribute);
        if cleaned.is_empty() {
            panic!(
                "attribute {} (\"{}\") has no letters or digits",
                index + 1,
                attribute
            );
        }
        // Cleaned text is ASCII, so byte length is character count.
        if segment_length > 0 && cleaned.len() > segment_length as usize {
            parts.push(cleaned[..segment_length as usize].to_string());
        } else {
            parts.push(cleaned);
        }
    }
    parts.join("-")
}

pub fn fune_vector(args: &[Value]) -> Value {
    let attributes: Vec<String> = args[1]
        .as_arr()
        .iter()
        .map(|v| v.as_str().to_string())
        .collect();
    Value::Str(generate_sku(args[0].as_str(), &attributes, args[2].as_i64()))
}

Install

fune build

With that line in your source, in a Rust project (language rust in fune.project), fune build resolves it and nothing else, pins them in fune.lock, downloads only the Rust package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. A crate’s build.rs runs it before every compile. Or pin a range in fune.project and build in one step:

fune add retail.sku-generate

The manifest, vectors and README with only the Rust implementation. Install it without the registry with fune add ./retail.sku-generate-1.0.0-rust.fune, or fetch it from a terminal with fune pull retail.sku-generate@1.0.0:rust.

The whole function, every language, is one file too: retail.sku-generate-1.0.0.fune, 10,804 bytes, sha256 7ef658222abadfe67f4a35e4484720e326cfec7c0c1a48b09861c4ff9050d9db. It installs into a project of any language.

// fune: before retail.sku-generate

// fune: after retail.sku-generate

// fune: step retail.sku-generate after <n|label>

More from the author

1. Each part (the prefix, then each attribute in the order given) keeps only the ASCII letters and digits `A-Z a-z 0-9`, in order. Spaces, punctuation and every non-ASCII character are dropped. 2. What is left is uppercased. 3. Each attribute, not the prefix, is cut to its first `segmentLength` characters. `0` keeps it whole. 4. The parts are joined with `-`. An empty prefix is left out.

Filtering happens before uppercasing on purpose: German sharp s uppercases to "SS" in all three languages, so uppercasing first would turn "Straße" into `STRASSE` in some places and `STRAE` in others. Here it is always `STRAE`. Accented letters are dropped, not transliterated ("Crème" is `CRME`); run the attribute through `text.slugify` first if you want `CREME`.

## What it does not do

It does not guarantee uniqueness. Two attributes that agree in their first `segmentLength` characters collide ("Brown" and "Bronze" are both `BRO` at 3), and so do "10.5" and "105" (both `105`). A SKU scheme with a fixed segment length needs a catalogue-level check, or a longer segment, and that belongs to whoever owns the catalogue. The order of the attributes is part of the SKU, so fix it per product family (colour, then size, then material).

## Errors

No attributes, a negative `segmentLength`, or a prefix or attribute with no letters or digits at all (`"***"`) are errors, because a SKU with an empty segment would silently collide with its neighbours.

Files