Updated fuzzel to use the lua 5.1 way of doing modules

1 files changed, 58 insertions, 33 deletions

diff --git a/fuzzel.lua b/fuzzel.lua
index 5943e8d..bc90984 100644
--- a/fuzzel.lua
+++ b/fuzzel.lua
@@ -45,10 +45,33 @@
         fuzzel.FuzzySearchRatio(string_needle, vararg_in)
             in may be either a table, or a list of arguments. Same as above, except it returns the string with the closest Damerau-Levenshtien ratio.
             returns string_closest, nubmer_ratio
+
+    Example:
+        Returns a function that will return the closest string to the string it was passed
+        -----------------FuzzelExample.lua------------------
+        local fuzzel = dofile("fuzzel.lua")
+
+        function suggestoption(tbl_options)
+            return function(str)
+                local closest = fuzzel.FuzzySearchDistance(str,tbl_options)
+                return closest
+            end
+        end
+
+        local options = {
+            "Fat Cat",
+            "Lazy Dog",
+            "Brown Fox",
+        }
+        local suggestfunc = suggestoption(options)
+
+        suggestfunc("Brown Cat")
+        -------------End FuzzelExample.lua------------------
+
 ]]
 local strlen,chrat,min,asrt,prs,iprs,typ,upack = string.len,string.byte,math.min,assert,pairs,ipairs,type,unpack
 
-module("fuzzel")
+local fuzzel = {}
 
 local function genericDistance( stringa, stringb, addcost, subcost, delcost, ...)
     --Length of each string
@@ -91,33 +114,33 @@ local function genericDistance( stringa, stringb, addcost, subcost, delcost, ...
     return dyntbl[salen][sblen]
 end
 
-function LevenshtienDistance_extended(stringa, stringb, addcost, subcost, delcost)
-    return genericDistance(stringa, stringb, addcost, subcost, delcost)
+function fuzzel.LevenshtienDistance_extended(stringa, stringb, addcost, subcost, delcost)
+    return fuzzel.genericDistance(stringa, stringb, addcost, subcost, delcost)
 end
 
-function LevenshtienDistance(stringa,stringb)
-    return LevenshtienDistance_extended(stringa,stringb,1,1,1)
+function fuzzel.LevenshtienDistance(stringa,stringb)
+    return fuzzel.LevenshtienDistance_extended(stringa,stringb,1,1,1)
 end
 
 --The distance as a ratio of stringa's length
-function LevenshteinRatio(stringa,stringb)
-    return LevenshtienDistance(stringa,stringb) / strlen(stringa)
+function fuzzel.LevenshteinRatio(stringa,stringb)
+    return fuzzel.LevenshtienDistance(stringa,stringb) / strlen(stringa)
 end
 --Almost the same as LevenshtienDistance, but considers two characters swaped as only "one" mistake
-function DamerauLevenshtienDistance_extended(stringa, stringb, addcost, subcost, delcost, trncost)
+function fuzzel.DamerauLevenshtienDistance_extended(stringa, stringb, addcost, subcost, delcost, trncost)
     return genericDistance(stringa,stringb,addcost,subcost,delcost,true,trncost)
 end
 
-function DamerauLevenshtienDistance(stringa,stringb)
-    return DamerauLevenshtienDistance_extended(stringa,stringb,1,1,1,1)
+function fuzzel.DamerauLevenshtienDistance(stringa,stringb)
+    return fuzzel.DamerauLevenshtienDistance_extended(stringa,stringb,1,1,1,1)
 end
 
-function DamerauLevenshtienRatio(stringa,stringb)
-    return DamerauLevenshtienDistance(stringa,stringb) / strlen(stringa)
+function fuzzel.DamerauLevenshtienRatio(stringa,stringb)
+    return fuzzel.DamerauLevenshtienDistance(stringa,stringb) / strlen(stringa)
 end
 
 --Purely the number of mistakes
-function HammingDistance(stringa,stringb)
+function fuzzel.HammingDistance(stringa,stringb)
     local len = strlen(stringa)
     asrt(len == strlen(stringb),"Hamming Distance cannot be calculated on two strings of different lengths:\"" .. stringa .. "\" \"" .. stringb .. "\"")
     local dist = 0
@@ -127,15 +150,15 @@ function HammingDistance(stringa,stringb)
     return dist
 end
 
-function HammingRatio(stringa,stringb)
-    return HammingDistance(stringa,stringb) / strlen(stringa)
+function fuzzel.HammingRatio(stringa,stringb)
+    return fuzzel.HammingDistance(stringa,stringb) / strlen(stringa)
 end
 
 local function FuzzySearch(str,func,...)
-    local itrfunc = typ(arg[1]) == "table" and prs or iprs
-    local tmin = func(arg[1],str)
-    local sout = arg[1]
-    for k,v in itrfunc(arg) do
+    local looparg = typ(arg[1]) == "table" and arg[1] or arg
+    local tmin = func(looparg[1],str)
+    local sout = looparg[1]
+    for k,v in prs(looparg) do
         local t = func(v,str)
         if t < tmin then
             tmin = t
@@ -145,22 +168,24 @@ local function FuzzySearch(str,func,...)
     return sout, tmin
 end
 
-function FuzzySearchDistance(str,...)
-    return upack{FuzzySearch(str,DamerauLevenshtienDistance,...)}
+function fuzzel.FuzzySearchDistance(str,...)
+    return upack{FuzzySearch(str,fuzzel.DamerauLevenshtienDistance,...)}
 end
 
-function FuzzySearchRatio(str,...)
-    return upack{FuzzySearch(str,DamerauLevenshtienRatio,...)}
+function fuzzel.FuzzySearchRatio(str,...)
+    return upack{FuzzySearch(str,fuzzel.DamerauLevenshtienRatio,...)}
 end
 
 --Some easy-to-use mnemonics
-ld_e = LevenshtienDistance_extended
-ld = LevenshtienDistance
-lr = LevensteinRatio
-dld_e = DamerauLevenshtienDistance_extended
-dld = DamerauLevenshtienDistance
-dlr = DamerauLevenshtienRatio
-hd = HammingDistance
-hr = HammingRatio
-fsd = FuzzySearchDistance
-fsr = FuzzySearchRatio
+fuzzel.ld_e = fuzzel.LevenshtienDistance_extended
+fuzzel.ld = fuzzel.LevenshtienDistance
+fuzzel.lr = fuzzel.LevensteinRatio
+fuzzel.dld_e = fuzzel.DamerauLevenshtienDistance_extended
+fuzzel.dld = fuzzel.DamerauLevenshtienDistance
+fuzzel.dlr = fuzzel.DamerauLevenshtienRatio
+fuzzel.hd = fuzzel.HammingDistance
+fuzzel.hr = fuzzel.HammingRatio
+fuzzel.fsd = fuzzel.FuzzySearchDistance
+fuzzel.fsr = fuzzel.FuzzySearchRatio
+
+return fuzzel