#myfreess/text

#Features

• Case Conversion: Convert strings to camelCase, PascalCase, snake_case, and kebab-case
• String Similarity: Calculate Levenshtein distance between strings
• Fuzzy Matching: Find closest matches from string arrays with customizable options
• Sorting by Similarity: Sort strings by their similarity to a target string
• Word Processing: Split strings into words and handle various text manipulations

#Installation

moon add myfreess/text

#API Reference

#Case Conversion Functions

#to_camel_case(String) -> String

test "camelCase conversion" {
  inspect(@text.to_camel_case("hello world"), content="helloWorld")
  inspect(@text.to_camel_case("deno_is_awesome"), content="denoIsAwesome")
  inspect(@text.to_camel_case("HTMLElement"), content="htmlElement")
}

#to_pascal_case(String) -> String

test "PascalCase conversion" {
  inspect(@text.to_pascal_case("hello world"), content="HelloWorld")
  inspect(@text.to_pascal_case("my_variable_name"), content="MyVariableName")
}

#to_snake_case(String) -> String

test "snake_case conversion" {
  inspect(@text.to_snake_case("Hello World"), content="hello_world")
  inspect(@text.to_snake_case("XMLHttpRequest"), content="xml_http_request")
}

#to_kebab_case(String) -> String

test "kebab-case conversion" {
  inspect(@text.to_kebab_case("Hello World"), content="hello-world")
  inspect(@text.to_kebab_case("backgroundColor"), content="background-color")
}

#String Similarity and Distance

#levenshtein_distance(String, String) -> Int

test "Levenshtein distance calculation" {
  inspect(@text.levenshtein_distance("kitten", "sitting"), content="3")
  inspect(@text.levenshtein_distance("hello", "hallo"), content="1")
  inspect(@text.levenshtein_distance("", "abc"), content="3")
  inspect(@text.levenshtein_distance("same", "same"), content="0")
}

#Fuzzy String Matching

#Configuration Types

• case_sensitive: Bool - Whether matching should be case-sensitive
• compare_fn: (String, String) -> Int - Custom comparison function

• case_sensitive: Bool - Whether comparison should be case-sensitive
• compare_fn: (String, String) -> Int - Custom comparison function

#Option Creators

test "create matching options" {
  let default_opts = @text.default_closest_string_options()
  let case_opts = @text.case_sensitive_closest_string_options()

  let similarity_opts = @text.default_compare_similarity_options()
  let case_similarity_opts = @text.case_sensitive_compare_similarity_options()
}

#closest_string(String, Array[String], ClosestStringOptions?) -> String raise StringMatchingError

test "find closest string" {
  let candidates = ["length", "size", "help", "world"]

  // Simple case - finds "help" as closest to "hep"
  let result = @text.closest_string_simple("hep", candidates)
  inspect(result, content="help")

  // With options
  let opts = @text.default_closest_string_options()
  let result2 = @text.closest_string("test", candidates, Some(opts))
  inspect(result2, content="help")
}

#closest_string_simple(String, Array[String]) -> String raise StringMatchingError

test "simple closest string matching" {
  let words = ["apple", "application", "apply", "apt"]
  let result = @text.closest_string_simple("app", words)
  inspect(result, content="apt")
}

#closest_strings(String, Array[String], Int, ClosestStringOptions?) -> Array[String]

test "multiple closest strings" {
  let candidates = ["help", "hello", "world", "test", "heap"]
  let top3 = @text.closest_strings("hep", candidates, 3, None)

  // Should return top 3 matches sorted by similarity
  inspect(top3.length(), content="3")
  inspect(top3[0], content="help")
}

#Similarity Comparison and Sorting

#compare_similarity(String, CompareSimilarityOptions?) -> (String, String) -> Int

test "similarity comparison function" {
  let compare_fn = @text.compare_similarity("target", None)
  let distance1 = compare_fn("target", "test")
  let distance2 = compare_fn("target", "target")

  inspect(distance2, content="0") // exact match
}

#compare_similarity_simple(String) -> (String, String) -> Int

test "simple similarity comparison" {
  let compare_fn = @text.compare_similarity_simple("hello")
  let distance = compare_fn("hello", "hallo")
  inspect(distance, content="-1")
}

#sort_by_similarity(Array[String], String, CompareSimilarityOptions?) -> Array[String]

test "sort by similarity" {
  let words = ["world", "help", "hello", "test"]
  let sorted = @text.sort_by_similarity(words, "hep", None)

  // "help" should be first as it's most similar to "hep"
  inspect(sorted[0], content="help")
}

#Utility Functions

#split_to_words(String) -> Array[String]

test "word splitting" {
  let words = @text.split_to_words("hello_world-test")
  @json.inspect(words, content=["hello", "world", "test"])

  let camel_words = @text.split_to_words("camelCaseExample")
  @json.inspect(camel_words, content=["camel", "Case", "Example"])
}

#capitalize_word(String) -> String

test "word capitalization" {
  inspect(@text.capitalize_word("hello"), content="Hello")
  inspect(@text.capitalize_word("WORLD"), content="World")
  inspect(@text.capitalize_word("tEST"), content="Test")
}

#to_lowercase_string(String) -> String

test "lowercase conversion" {
  inspect(@text.to_lowercase_string("Hello World"), content="hello world")
  inspect(@text.to_lowercase_string("TEST123"), content="test123")
}

#Error Handling

test "error handling" {
  let empty_array : Array[String] = []
  let result = try {
    @text.closest_string_simple("test", empty_array)
  } catch {
    @text.StringMatchingError(msg) => "Error: " + msg
  }

  inspect(result, content="Error: When using closest_string(), the possible_words array must contain at least one word")
}

#Performance Considerations

• The levenshtein_distance function has O(m × n) time complexity where m and n are string lengths
• For strings shorter than 32 characters, an optimized Myers algorithm is used
• For longer strings, the classic dynamic programming approach is employed
• Consider input validation for very long strings in production use

#Use Cases

#Command Line Tool Suggestions

test "CLI command suggestions" {
  let commands = ["install", "uninstall", "list", "search", "update"]
  let suggestion = @text.closest_string_simple("instal", commands)
  inspect(suggestion, content="install")
}

#API Method Name Matching

test "API method matching" {
  let methods = ["getUserById", "getUserByName", "getAllUsers", "createUser"]
  let closest = @text.closest_string_simple("getUser", methods)
  inspect(closest, content="getUserById")
}

#Variable Name Formatting

test "variable name formatting" {
  let api_name = "user profile data"

  inspect(@text.to_camel_case(api_name), content="userProfileData")
  inspect(@text.to_pascal_case(api_name), content="UserProfileData")
  inspect(@text.to_snake_case(api_name), content="user_profile_data")
  inspect(@text.to_kebab_case(api_name), content="user-profile-data")
}

#License