Merge pull request #40 from o-lim/arg-callback

Add callbacks for argument parsing

Author: amireh

spec/cliargs_parsing_spec.lua

@@ -315,13 +315,14 @@ describe("Testing cliargs library parsing commandlines", function()
     assert.are.equal("", result.compress)
   end)
 
-  describe("Tests parsing with callback", function()
+  describe("Tests options parsing with callback", function()
     local cb = {}
 
     local function callback(key, value, altkey, opt)
       cb.key, cb.value, cb.altkey = key, value, altkey
       return true
     end
+
     local function callback_fail(key, value, altkey, opt)
       return nil, "bad argument to " .. opt
     end
@@ -331,42 +332,124 @@ describe("Testing cliargs library parsing commandlines", function()
     end)
 
     it("tests short-key option", function()
-      cli:add_option("-k, --long-key=VALUE", "key descriptioin", "", callback)
+      cli:add_option("-k, --long-key=VALUE", "key description", "", callback)
       local expected = { k = "myvalue", ["long-key"] = "myvalue" }
       local result = cli:parse({ "-k", "myvalue" })
       assert.are.same(expected, result)
-      assert.are.equal(cb.key, "k")
-      assert.are.equal(cb.value, "myvalue")
-      assert.are.equal(cb.altkey, "long-key")
+      assert.are.equal("k", cb.key)
+      assert.are.equal("myvalue", cb.value)
+      assert.are.equal("long-key", cb.altkey)
     end)
 
     it("tests expanded-key option", function()
-      cli:add_option("-k, --long-key=VALUE", "key descriptioin", "", callback)
+      cli:add_option("-k, --long-key=VALUE", "key description", "", callback)
       local expected = { k = "val", ["long-key"] = "val" }
       local result = cli:parse({ "--long-key", "val" })
       assert.are.same(expected, result)
-      assert.are.equal(cb.key, "long-key")
-      assert.are.equal(cb.value, "val")
-      assert.are.equal(cb.altkey, "k")
+      assert.are.equal("long-key", cb.key)
+      assert.are.equal("val", cb.value)
+      assert.are.equal("k", cb.altkey)
     end)
 
     it("tests expanded-key flag with not short-key", function()
       cli:add_flag("--version", "prints the version and exits", callback)
       local expected = { version = true }
       local result = cli:parse({ "--version" })
       assert.are.same(expected, result)
-      assert.are.equal(cb.key, "version")
-      assert.are.equal(cb.value, true)
-      assert.are.equal(cb.altkey, nil)
+      assert.are.equal("version", cb.key)
+      assert.are.equal(true, cb.value)
+      assert.are.equal(nil, cb.altkey)
     end)
 
     it("tests callback returning error", function()
       cli:set_name('myapp')
-      cli:add_option("-k, --long-key=VALUE", "key descriptioin", "", callback_fail)
+      cli:add_option("-k, --long-key=VALUE", "key description", "", callback_fail)
       local result, err = cli:parse({ "--long-key", "val" }, true --[[no print]])
       assert(result == nil, "Failure in callback returns nil")
       assert(type(err) == "string", "Expected an error string")
       assert.are.equal(err, "myapp: error: bad argument to --long-key; re-run with --help for usage.")
     end)
   end)
+
+  describe("Tests argument parsing with callback", function()
+    local cb = {}
+
+    local function callback(key, value)
+      cb.key, cb.value = key, value
+      return true
+    end
+
+    local function callback_arg(key, value)
+      table.insert(cb, { key = key, value = value })
+      return true
+    end
+
+    local function callback_fail(key, value)
+      return nil, "bad argument for " .. key
+    end
+
+    before_each(function()
+      cb = {}
+    end)
+
+    it("tests one required argument", function()
+      cli:add_arg("ARG", "arg description", callback)
+      local expected = { ARG = "arg_val" }
+      local result = cli:parse({ "arg_val" })
+      assert.are.same(expected, result)
+      assert.are.equal("ARG", cb.key)
+      assert.are.equal("arg_val", cb.value)
+    end)
+
+    it("tests required argument callback returning error", function()
+      cli:set_name('myapp')
+      cli:add_arg("ARG", "arg description", callback_fail)
+      local expected = { ARG = "arg_val" }
+      local result, err = cli:parse({ "arg_val" }, true --[[no print]])
+      assert(result == nil, "Failure in callback returns nil")
+      assert(type(err) == "string", "Expected an error string")
+      assert.are.equal(err, "myapp: error: bad argument for ARG; re-run with --help for usage.")
+    end)
+
+    it("tests many required arguments", function()
+      cli:add_arg("ARG1", "arg1 description", callback_arg)
+      cli:add_arg("ARG2", "arg2 description", callback_arg)
+      cli:add_arg("ARG3", "arg3 description", callback_arg)
+      local expected = { ARG1 = "arg1_val", ARG2 = "arg2_val", ARG3 = "arg3_val" }
+      local result = cli:parse({ "arg1_val", "arg2_val", "arg3_val" })
+      assert.are.same(expected, result)
+      assert.are.same({ key = "ARG1", value = "arg1_val"}, cb[1])
+      assert.are.same({ key = "ARG2", value = "arg2_val"}, cb[2])
+      assert.are.same({ key = "ARG3", value = "arg3_val"}, cb[3])
+    end)
+
+    it("tests one optional argument", function()
+      cli:optarg("OPTARG", "optional arg description", nil, 1, callback)
+      local expected = { OPTARG = "opt_arg" }
+      local result = cli:parse({ "opt_arg" })
+      assert.are.same(expected, result)
+      assert.are.equal("OPTARG", cb.key)
+      assert.are.equal("opt_arg", cb.value)
+    end)
+
+    it("tests optional argument callback returning error", function()
+      cli:set_name('myapp')
+      cli:optarg("OPTARG", "optinoal arg description", nil, 1, callback_fail)
+      local expected = { ARG = "arg_val" }
+      local result, err = cli:parse({ "opt_arg" }, true --[[no print]])
+      assert(result == nil, "Failure in callback returns nil")
+      assert(type(err) == "string", "Expected an error string")
+      assert.are.equal(err, "myapp: error: bad argument for OPTARG; re-run with --help for usage.")
+    end)
+
+    it("tests many optional arguments", function()
+      cli:optarg("OPTARG", "optional arg description", nil, 3, callback_arg)
+      local expected = { OPTARG = { "opt_arg1", "opt_arg2", "opt_arg3" } }
+      local result = cli:parse({ "opt_arg1", "opt_arg2", "opt_arg3" })
+      assert.are.same(expected, result)
+      assert.are.same({ key = "OPTARG", value = "opt_arg1"}, cb[1])
+      assert.are.same({ key = "OPTARG", value = "opt_arg2"}, cb[2])
+      assert.are.same({ key = "OPTARG", value = "opt_arg3"}, cb[3])
+    end)
+  end)
 end)

src/cliargs.lua

@@ -95,6 +95,10 @@ local function disect(key)
   return k,ek,v
 end
 
+local function callable(fn)
+  return type(fn) == "function" or (getmetatable(fn) or {}).__call
+end
+
 
 function cli_error(msg, noprint)
   local msg = cli.name .. ": error: " .. msg .. '; re-run with --help for usage.'
@@ -140,23 +144,25 @@ end
 --- ### Parameters
 --- 1. **key**: the argument's "name" that will be displayed to the user
 --- 2. **desc**: a description of the argument
+--- 3. **callback**: *optional*; specify a function to call when this argument is parsed (the default is nil)
 ---
 --- ### Usage example
 --- The following will parse the argument (if specified) and set its value in `args["root"]`:
 --- `cli:add_arg("root", "path to where root scripts can be found")`
-function cli:add_arg(key, desc)
+function cli:add_arg(key, desc, callback)
   assert(type(key) == "string" and type(desc) == "string", "Key and description are mandatory arguments (Strings)")
+  assert(callable(callback) or callback == nil, "Callback argument: expected a function or nil")
 
   if self:__lookup(key, nil, self.required) then
     error("Duplicate argument: " .. key .. ", please rename one of them.")
   end
 
-  table.insert(self.required, { key = key, desc = desc, value = nil })
+  table.insert(self.required, { key = key, desc = desc, value = nil, callback = callback })
   if #key > self.maxlabel then self.maxlabel = #key end
 end
 
 --- Defines an optional argument (or more than one).
---- There can be only 1 optional argument, and is has to be the last one on the argumentlist.
+--- There can be only 1 optional argument, and it has to be the last one on the argumentlist.
 --- *Note:* the value will be stored in `args[@key]`. The value will be a 'string' if 'maxcount == 1',
 --- or a table if 'maxcount > 1'
 ---
@@ -165,19 +171,21 @@ end
 --- 2. **desc**: a description of the argument
 --- 3. **default**: *optional*; specify a default value (the default is nil)
 --- 4. **maxcount**: *optional*; specify the maximum number of occurences allowed (default is 1)
+--- 5. **callback**: *optional*; specify a function to call when this argument is parsed (the default is nil)
 ---
 --- ### Usage example
 --- The following will parse the argument (if specified) and set its value in `args["root"]`:
 --- `cli:add_arg("root", "path to where root scripts can be found", "", 2)`
 --- The value returned will be a table with at least 1 entry and a maximum of 2 entries
-function cli:optarg(key, desc, default, maxcount)
+function cli:optarg(key, desc, default, maxcount, callback)
   assert(type(key) == "string" and type(desc) == "string", "Key and description are mandatory arguments (Strings)")
   assert(type(default) == "string" or default == nil, "Default value must either be omitted or be a string")
   maxcount = maxcount or 1
   maxcount = tonumber(maxcount)
   assert(maxcount and maxcount>0 and maxcount<1000,"Maxcount must be a number from 1 to 999")
+  assert(callable(callback) or callback == nil, "Callback argument: expected a function or nil")
 
-  self.optargument = { key = key, desc = desc, default = default, maxcount = maxcount, value = nil }
+  self.optargument = { key = key, desc = desc, default = default, maxcount = maxcount, value = nil, callback = callback }
   if #key > self.maxlabel then self.maxlabel = #key end
 end
 
@@ -210,6 +218,7 @@ function cli:add_opt(key, desc, default, callback)
   -- 8. --expanded=VALUE
 
   assert(type(key) == "string" and type(desc) == "string", "Key and description are mandatory arguments (Strings)")
+  assert(callable(callback) or callback == nil, "Callback argument: expected a function or nil")
   assert(
     (
       type(default) == "string"
@@ -219,14 +228,6 @@ function cli:add_opt(key, desc, default, callback)
     ),
     "Default argument: expected a string, nil, or {}"
   )
-  assert(
-    (
-      type(callback) == "function"
-      or callback == nil
-      or (getmetatable(callback) or {}).__call
-    ),
-    "Callback argument: expected a function or nil"
-  )
 
   local k, ek, v = disect(key)
 
@@ -409,6 +410,12 @@ function cli:parse(arguments, noprint, dump)
   -- deal with required args here
   for i, entry in ipairs(self.required) do
     entry.value = args[1]
+    if entry.callback then
+      local status, err = entry.callback(entry.key, entry.value)
+      if status == nil and err then
+        return cli_error(err, noprint)
+      end
+    end
     table.remove(args, 1)
   end
   -- deal with the last optional argument
@@ -419,6 +426,12 @@ function cli:parse(arguments, noprint, dump)
     else
       self.optargument.value = args[1]
     end
+    if self.optargument.callback then
+      local status, err = self.optargument.callback(self.optargument.key, args[1])
+      if status == nil and err then
+        return cli_error(err, noprint)
+      end
+    end
     table.remove(args,1)
   end
   -- if necessary set the defaults for the last optional argument here