Files

greetings.src libs/thor.src
greetings.src
  • Greetings = {}
  • Greetings.greetings_sig = {}
  • Greetings.greetings_sig["description"] = "shit cli script"
  • //required args should come first than optional ones
  • Greetings.greetings_sig["args"] = ["name*", "second_name"]
  • Greetings.greetings_sig["options"] = [{["-c", "--capitalize"]: "the names"}, {["-f=", "--from="]: "from name"}]
  • Greetings.greetings_sig["options"] = [{["-c", "--capitalize"]: "capitalize the names"}, {["-f=", "--from="]: "from name"}]
  • capitalize = function(s)
  • s = s.values
  • s[0] = s[0].upper
  • return s.join("")
  • end function
  • Greetings.greetings = function(args = [], options = {})
  • print("hellow")
  • name = args[0]
  • second_name = args[1]
  • if second_name == null then second_name = ""
  • from = options["-f="]
  • if from == null then from = ""
  • if options["-c"] then
  • name = capitalize(name)
  • if second_name != "" then second_name = capitalize(second_name)
  • if from != "" then from = capitalize(from)
  • end if
  • out = ""
  • if from != "" then out = out + "from " + from + ": "
  • out = out + ["hello", name, second_name].join(" ")
  • print(out)
  • end function
  • import_code("/home/me/Thorr/libs/listLib.src") //requires on listlib
  • import_code("/home/me/Thorr/libs/thor.src") //requires on listlib
  • Thor.init(Greetings, "greetings")
libs/thor.src
  • ThorCommand = {}
  • ThorCommand.init = function(func, sig, name)
  • self.name = name
  • self.func = @func
  • if sig.hasIndex("description") then self.description = sig["description"]
  • if sig.hasIndex("args") then
  • self.args = sig["args"]
  • end if
  • if sig.hasIndex("options") then
  • f = function(obj)
  • param = {}
  • param["name"] = obj.indexes[0]
  • param["description"] = obj[obj.indexes[0]]
  • return param
  • end function
  • self.options = Lst.map(sig["options"], @f)
  • end if
  • end function
  • ThorCommand.required_args = function()
  • f = function(obj)
  • return obj[-1:] == "*"
  • end function
  • return Lst.select(self.args, @f)
  • end function
  • ThorCommand.optional_args = function()
  • f = function(obj)
  • return self.required_args.indexOf(obj) == null
  • end function
  • return Lst.select(self.args, @f)
  • end function
  • ThorCommand.options_list = function()
  • f = function(o)
  • return o.name
  • end function
  • return Lst.map(self.options, @f)
  • end function
  • ThorCommand.args_help = function()
  • out = self.name
  • for arg in self.args
  • out = out + " " + arg
  • end for
  • return out
  • end function
  • ThorCommand.options_help = function()
  • out = "options for " + self.name + ":" + char(10)
  • for i in self.options
  • n = i.name
  • if typeof(i.name) == "list" then n = i.name.join(" or ")
  • out = out + n + " : " + i.description
  • if self.options.indexOf(i) < self.options.len - 1 then out = out + char(10)
  • end for
  • return out
  • end function
  • ThorCommand.help = function()
  • out = self.args_help + char(10) + char(10)
  • out = out + self.options_help
  • return out
  • end function
  • ThorCommand.exec = function()
  • self.func(self.passed_args, self.passed_options)
  • end function
  • // class divider ---------------------------------------
  • ThorManager = {}
  • ThorManager.init = function(thor)
  • self.thor = thor
  • end function
  • ThorManager.eval_command = function(command)
  • used_args = self.thor.global_args[:command.args.len]
  • self.thor.global_args = self.thor.global_args[command.args.len:]
  • self.thor.used_options = self.thor.used_options + Lst.flat(command.options_list)
  • for i in range(command.args.len - used_args.len - 1)
  • used_args.push(null)
  • end for
  • command["passed_args"] = used_args
  • command["passed_options"] = self.options_by_key(command)
  • self.thor.global_execution_queue.push(command)
  • end function
  • ThorManager.options_by_key = function(command)
  • r = {}
  • get_value = function(o)
  • if o.indexOf("=") then
  • striped_options = self.thor.striped_global_options
  • if striped_options.indexOf(o) then
  • value = self.thor.global_options[striped_options.indexOf(o)]
  • return value[value.indexOf("=")+1:]
  • else
  • return null
  • end if
  • else
  • if self.thor.global_options.indexOf(i) != null then return true
  • return null
  • end if
  • end function
  • for o in command.options_list
  • if typeof(o) == "list" then
  • v = null
  • for i in o
  • if get_value(i) != null then v = get_value(i)
  • end for
  • for i in o
  • r[i] = v
  • end for
  • else
  • r[o] = get_value(o)
  • end if
  • end for
  • return r
  • end function
  • // class divider ---------------------------------------
  • Thor = {}
  • Thor.init = function(class, main_func_name)
  • self.class = null
  • self.global_args = []
  • self.passed_args_count = 0
  • self.global_options = []
  • self.used_options = []
  • self.global_execution_queue = []
  • self.manager = new ThorManager
  • self.manager.init(self)
  • main_command = new ThorCommand
  • main_command.init(class[main_func_name], class[main_func_name+"_sig"], main_func_name)
  • self.params_to_args_options(params)
  • self.manager.eval_command(main_command)
  • self.catch_errors
  • self.exec_queue
  • end function
  • Thor.striped_global_options = function()
  • f = function(ob)
  • if ob.indexOf("=") then
  • return ob[:ob.indexOf("=")+1]
  • end if
  • end function
  • return Lst.map(self.global_options, @f)
  • end function
  • Thor.params_to_args_options = function(params)
  • // filter for args
  • f = function(p)
  • return p[0] == "-"
  • end function
  • args = Lst.reject(params, @f)
  • options = {}
  • f = function(param)
  • return param[:1] == "-" and param.indexOf("=") == null
  • end function
  • params_options = Lst.select(params, @f)
  • f = function(param)
  • if param[:2] != "--" and param.len > 2 then
  • r = []
  • for i in param[1:].values
  • r.push("-" + i)
  • end for
  • return r
  • else
  • return param
  • end if
  • end function
  • params_options = Lst.uniq(Lst.flat(Lst.map(params_options, @f)))
  • f = function(param)
  • return param[:1] == "-" and param.indexOf("=") != null
  • end function
  • params_value_options = Lst.select(params, @f)
  • options = params_options + params_value_options
  • self.global_args = args
  • self.passed_args_count = args.len
  • self.global_options = options
  • end function
  • Thor.catch_errors = function()
  • f = function(c)
  • return c.required_args.len
  • end function
  • required_args = Lst.map(self.global_execution_queue, @f)
  • if self.passed_args_count < required_args.sum then
  • print("error: required params not passed"+char(10))
  • print("error: required params not passed, check the docs")
  • exit()
  • end if
  • print(self.striped_global_options)
  • print(self.used_options)
  • used_options = self.used_options + ["-h", "--help"] //cant use self inside the block
  • f = function(p)
  • return used_options.indexOf(p) == null
  • end function
  • undefined_options = Lst.select(self.striped_global_options, @f)
  • for i in undefined_options
  • print("error: " + i + " option is not defined, check the docs")
  • exit()
  • end for
  • if self.global_options.indexOf("-h") != null or self.global_options.indexOf("--help") != null then
  • print(self.global_execution_queue[-1].help)
  • exit()
  • end if
  • end function
  • Thor.exec_queue = function()
  • self.global_execution_queue[-1].exec
  • end function