Initial commit

Author: stein197

.gitignore

@@ -0,0 +1,5 @@
+/luarocks.bat
+/lua.bat
+/lua_modules
+/.luarocks
+/*.rock

CHANGELOG.md

@@ -0,0 +1,5 @@
+# CHANGELOG
+## Unreleased
+
+## [1.0.0](../../tree/1.0.0) - 2021-11-30
+Release

LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2021 Nail' Gafarov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
+OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,53 @@
+# Tiny try-catch-finally implementation for Lua
+![](https://img.shields.io/github/license/stein197/lua-catchify)
+![](https://img.shields.io/github/v/tag/stein197/lua-catchify?label=Version)
+![](https://img.shields.io/luarocks/v/stein197/lua-catchify)
+
+Lua does not have a common syntax sugar to wrap the code that will possibly lead to errors. This package provides a very simple way to bring this sugar to Lua.
+
+## Installation
+Via LuaRocks:
+```
+luarocks install catchify
+```
+Or just download and require `init.lua` file from this repo.
+
+## Usage
+The whole concept can be illustrated in a single code piece below:
+```lua
+local try = require "catchify"
+try(function ()
+	error "Something's wrong!"
+end):catch(function (e) -- e will contain error message
+	print(e) -- > stdin:3: Something's wrong!
+end):finally(function () -- Will be executed anyway
+	print "Finally here!"
+end)
+```
+
+You can pass a table containing single function instead of a function to make syntax more "curly":
+```lua
+try {
+	function ()
+		error "Something's wrong!"
+	end
+} :catch {
+	function (e)
+		print(e)
+	end
+} :finally {
+	function ()
+		print "Finally here!"
+	end
+}
+```
+
+## Testing
+Install luaunit package:
+```
+luarocks install luaunit
+```
+Then run from the console:
+```
+lua test.lua
+```

catchify-1.0.0-1.rockspec

@@ -0,0 +1,31 @@
+package = "catchify"
+rockspec_format = "3.0"
+version = "1.0.0-1"
+source = {
+	url = "git://github.com/stein197/lua-catchify",
+	tag = "1.0.0",
+	branch = "main"
+}
+description = {
+	summary = "Tiny try-catch-finally implementation for Lua",
+	detailed = [[
+		Lua does not have a common syntax sugar to wrap the code that will possibly lead to errors. This package
+		provides a very simple way to bring this sugar to Lua
+	]],
+	homepage = "https://github.com/stein197/lua-catchify",
+	issues_url = "https://github.com/stein197/lua-catchify/issues",
+	license = "MIT",
+	maintainer = "Nail' Gafarov <[email protected]>",
+	labels = {
+		"try", "catch", "finally"
+	}
+}
+dependencies = {
+	"lua >= 5.3"
+}
+build = {
+	type = "builtin",
+	modules = {
+		["catchify"] = "init.lua"
+	}
+}

init.lua

@@ -0,0 +1,29 @@
+local function getcallback(f)
+	return type(f) == "table" and f[1] or f
+end
+
+local metatable = {
+	__index = {
+		catch = function (self, f)
+			if not self.ok then
+				getcallback(f)(self.rs)
+			end
+			return self
+		end;
+
+		finally = function (self, f)
+			getcallback(f)()
+		end;
+	}
+}
+
+local function ctor(ok, rs)
+	return setmetatable({
+		ok = ok,
+		rs = rs
+	}, metatable)
+end
+
+return function (f)
+	return ctor(pcall(getcallback(f)))
+end

test.lua

@@ -0,0 +1,108 @@
+local try = require ""
+local luaunit = require "luaunit"
+
+TestCatchify = {
+
+	["test: Error in try() is being silent"] = function ()
+		try(
+			function ()
+				error "Error"
+			end
+		)
+		try {
+			function ()
+				error "Error"
+			end
+		}
+	end;
+
+	["test: Error in try() is being processed in catch()"] = function ()
+		local var1
+		local var2
+		try(function ()
+			error "Error"
+		end):catch(function (msg)
+			var1 = msg
+		end)
+		try {
+			function ()
+				error "Error"
+			end
+		} :catch {
+			function (msg)
+				var2 = msg
+			end
+		}
+		luaunit.assertStrContains(var1, "Error")
+		luaunit.assertStrContains(var2, "Error")
+	end;
+
+	["test: No errors in try() won't make catch() execute"] = function ()
+		local var1
+		local var2
+		try(function () end):catch(function (msg)
+			var1 = msg
+		end)
+		try {
+			function () end
+		} :catch {
+			function (msg)
+				var2 = msg
+			end
+		}
+		luaunit.assertNil(var1)
+		luaunit.assertNil(var2)
+	end;
+
+	["test: finally() executes after error in try()"] = function ()
+		local var1
+		local var2
+		try(function ()
+			error "Error"
+		end):catch(function (msg)
+			var1 = msg
+		end):finally(function ()
+			var1 = "Finally"
+		end)
+		try {
+			function ()
+				error "Error"
+			end
+		} :catch {
+			function (msg)
+				var2 = msg
+			end
+		} :finally {
+			function ()
+				var2 = "Finally"
+			end
+		}
+		luaunit.assertEquals(var1, "Finally")
+		luaunit.assertEquals(var2, "Finally")
+	end;
+
+	["test: finally() executes after no errors in try()"] = function ()
+		local var1
+		local var2
+		try(function () end):catch(function (msg)
+			var1 = msg
+		end):finally(function ()
+			var1 = "Finally"
+		end)
+		try {
+			function () end
+		} :catch {
+			function (msg)
+				var2 = msg
+			end
+		} :finally {
+			function ()
+				var2 = "Finally"
+			end
+		}
+		luaunit.assertEquals(var1, "Finally")
+		luaunit.assertEquals(var2, "Finally")
+	end;
+}
+
+os.exit(luaunit.run())