Added ltn12 module. Modified mime to be stand alone.

Still crashes on invalid input. Dunno why.

1 files changed, 25 insertions, 49 deletions

diff --git a/src/mime.lua b/src/mime.lua
index 369567f..4df0388 100644
--- a/src/mime.lua
+++ b/src/mime.lua
@@ -1,11 +1,6 @@
--- make sure LuaSocket is loaded
-if not LUASOCKET_LIBNAME then error('module requires LuaSocket') end
--- get LuaSocket namespace
-local socket = _G[LUASOCKET_LIBNAME] 
-if not socket then error('module requires LuaSocket') end
--- create code namespace inside LuaSocket namespace
-local mime = socket.mime or {}
-socket.mime = mime
+if not ltn12 then error('This module requires LTN12') end
+-- create mime namespace
+mime = mime or {}
 -- make all module globals fall into mime namespace
 setmetatable(mime, { __index = _G })
 setfenv(1, mime)
@@ -15,80 +10,61 @@ local et = {}
 local dt = {}
 local wt = {}
 
--- creates a function that chooses a filter from a given table 
+-- creates a function that chooses a filter by name from a given table 
 local function choose(table)
-    return function(filter, ...)
-        local f = table[filter or "nil"]
-        if not f then error("unknown filter (" .. tostring(filter) .. ")", 3)
-        else return f(unpack(arg)) end
+    return function(name, opt)
+        local f = table[name or "nil"]
+        if not f then error("unknown filter (" .. tostring(name) .. ")", 3)
+        else return f(opt) end
     end
 end
 
 -- define the encoding filters
 et['base64'] = function()
-    return socket.cicle(b64, "")
+    return ltn12.filter.cycle(b64, "")
 end
 
 et['quoted-printable'] = function(mode)
-    return socket.cicle(qp, "", (mode == "binary") and "=0D=0A" or "\13\10")
+    return ltn12.filter.cycle(qp, "", 
+        (mode == "binary") and "=0D=0A" or "\13\10")
 end
 
 -- define the decoding filters
 dt['base64'] = function()
-    return socket.cicle(unb64, "")
+    return ltn12.filter.cycle(unb64, "")
 end
 
 dt['quoted-printable'] = function()
-    return socket.cicle(unqp, "")
+    return ltn12.filter.cycle(unqp, "")
 end
 
 -- define the line-wrap filters
 wt['text'] = function(length)
     length = length or 76
-    return socket.cicle(wrp, length, length) 
+    return ltn12.filter.cycle(wrp, length, length) 
 end
 wt['base64'] = wt['text']
 
 wt['quoted-printable'] = function()
-    return socket.cicle(qpwrp, 76, 76) 
+    return ltn12.filter.cycle(qpwrp, 76, 76) 
 end
 
 -- function that choose the encoding, decoding or wrap algorithm
 encode = choose(et) 
 decode = choose(dt)
--- there is a default wrap filter
+-- there is different because there is a default wrap filter
 local cwt = choose(wt)
-function wrap(...)
-    if type(arg[1]) ~= "string" then table.insert(arg, 1, "text") end
-    return cwt(unpack(arg))
-end
-
--- define the end-of-line translation filter
-function canonic(marker)
-    return socket.cicle(eol, "", marker)
+function wrap(mode_or_length, length)
+    if type(mode_or_length) ~= "string" then
+        length = mode_or_length
+        mode_or_length = "text"
+    end
+    return cwt(mode_or_length, length)
 end
 
--- chains several filters together
-function chain(...)
-    local layers = table.getn(arg)
-    return function (chunk)
-        if not chunk then
-            local parts = {}
-            for i = 1, layers do
-                for j = i, layers do
-                    chunk = arg[j](chunk)
-                end
-                table.insert(parts, chunk)
-                chunk = nil
-            end
-            return table.concat(parts)
-        else
-            for j = 1, layers do
-                chunk = arg[j](chunk)
-            end
-            return chunk
-        end
-    end
+-- define the end-of-line normalization filter
+function normalize(marker)
+    return ltn12.filter.cycle(eol, 0, marker)
 end
 
 return mime