refactor: add mason-schemas and mason-core modules (#29)

* refactor: add mason-schemas and move generated filetype map to mason-lspconfig

* refactor: add mason-core module

9 files changed, 0 insertions, 626 deletions

diff --git a/tests/core/functional/data_spec.lua b/tests/core/functional/data_spec.lua
deleted file mode 100644
index cdc26809..00000000
--- a/tests/core/functional/data_spec.lua
+++ /dev/null
@@ -1,28 +0,0 @@
-local _ = require "mason.core.functional"
-
-describe("functional: data", function()
-    it("creates enums", function()
-        local colors = _.enum {
-            "BLUE",
-            "YELLOW",
-        }
-        assert.same({
-            ["BLUE"] = "BLUE",
-            ["YELLOW"] = "YELLOW",
-        }, colors)
-    end)
-
-    it("creates sets", function()
-        local colors = _.set_of {
-            "BLUE",
-            "YELLOW",
-            "BLUE",
-            "RED",
-        }
-        assert.same({
-            ["BLUE"] = true,
-            ["YELLOW"] = true,
-            ["RED"] = true,
-        }, colors)
-    end)
-end)
diff --git a/tests/core/functional/function_spec.lua b/tests/core/functional/function_spec.lua
deleted file mode 100644
index 21951dc3..00000000
--- a/tests/core/functional/function_spec.lua
+++ /dev/null
@@ -1,142 +0,0 @@
-local spy = require "luassert.spy"
-local match = require "luassert.match"
-local _ = require "mason.core.functional"
-
-describe("functional: function", function()
-    it("curries functions", function()
-        local function sum(...)
-            local res = 0
-            for i = 1, select("#", ...) do
-                res = res + select(i, ...)
-            end
-            return res
-        end
-        local arity0 = _.curryN(sum, 0)
-        local arity1 = _.curryN(sum, 1)
-        local arity2 = _.curryN(sum, 2)
-        local arity3 = _.curryN(sum, 3)
-
-        assert.equals(0, arity0(42))
-        assert.equals(42, arity1(42))
-        assert.equals(3, arity2(1)(2))
-        assert.equals(3, arity2(1, 2))
-        assert.equals(6, arity3(1)(2)(3))
-        assert.equals(6, arity3(1, 2, 3))
-
-        -- should discard superfluous args
-        assert.equals(0, arity1(0, 10, 20, 30))
-    end)
-
-    it("coalesces first non-nil value", function()
-        assert.equal("Hello World!", _.coalesce(nil, nil, "Hello World!", ""))
-    end)
-
-    it("should compose functions", function()
-        local function add(x)
-            return function(y)
-                return y + x
-            end
-        end
-        local function subtract(x)
-            return function(y)
-                return y - x
-            end
-        end
-        local function multiply(x)
-            return function(y)
-                return y * x
-            end
-        end
-
-        local big_maths = _.compose(add(1), subtract(3), multiply(5))
-
-        assert.equals(23, big_maths(5))
-    end)
-
-    it("should not allow composing no functions", function()
-        local e = assert.error(function()
-            _.compose()
-        end)
-        assert.equals("compose requires at least one function", e)
-    end)
-
-    it("should partially apply functions", function()
-        local funcy = spy.new()
-        local partially_funcy = _.partial(funcy, "a", "b", "c")
-        partially_funcy("d", "e", "f")
-        assert.spy(funcy).was_called_with("a", "b", "c", "d", "e", "f")
-    end)
-
-    it("should partially apply functions with nil arguments", function()
-        local funcy = spy.new()
-        local partially_funcy = _.partial(funcy, "a", nil, "c")
-        partially_funcy("d", nil, "f")
-        assert.spy(funcy).was_called_with("a", nil, "c", "d", nil, "f")
-    end)
-
-    it("memoizes functions with default cache mechanism", function()
-        local expensive_function = spy.new(function(s)
-            return s
-        end)
-        local memoized_fn = _.memoize(expensive_function)
-        assert.equal("key", memoized_fn "key")
-        assert.equal("key", memoized_fn "key")
-        assert.equal("new_key", memoized_fn "new_key")
-        assert.spy(expensive_function).was_called(2)
-    end)
-
-    it("memoizes function with custom cache mechanism", function()
-        local expensive_function = spy.new(function(arg1, arg2)
-            return arg1 .. arg2
-        end)
-        local memoized_fn = _.memoize(expensive_function, function(arg1, arg2)
-            return arg1 .. arg2
-        end)
-        assert.equal("key1key2", memoized_fn("key1", "key2"))
-        assert.equal("key1key2", memoized_fn("key1", "key2"))
-        assert.equal("key1key3", memoized_fn("key1", "key3"))
-        assert.spy(expensive_function).was_called(2)
-    end)
-
-    it("should evaluate functions lazily", function()
-        local impl = spy.new(function()
-            return {}, {}
-        end)
-        local lazy_fn = _.lazy(impl)
-        assert.spy(impl).was_called(0)
-        local a, b = lazy_fn()
-        assert.spy(impl).was_called(1)
-        assert.is_true(match.is_table()(a))
-        assert.is_true(match.is_table()(b))
-        local new_a, new_b = lazy_fn()
-        assert.spy(impl).was_called(1)
-        assert.is_true(match.is_ref(a)(new_a))
-        assert.is_true(match.is_ref(b)(new_b))
-    end)
-
-    it("should support nil return values in lazy functions", function()
-        local lazy_fn = _.lazy(function()
-            return nil, 2
-        end)
-        local a, b = lazy_fn()
-        assert.is_nil(a)
-        assert.equal(2, b)
-    end)
-
-    it("should provide identity value", function()
-        local obj = {}
-        assert.equals(2, _.identity(2))
-        assert.equals(obj, _.identity(obj))
-    end)
-
-    it("should always return bound value", function()
-        local obj = {}
-        assert.equals(2, _.always(2)())
-        assert.equals(obj, _.always(obj)())
-    end)
-
-    it("true is true and false is false", function()
-        assert.is_true(_.T())
-        assert.is_false(_.F())
-    end)
-end)
diff --git a/tests/core/functional/list_spec.lua b/tests/core/functional/list_spec.lua
deleted file mode 100644
index a03fee68..00000000
--- a/tests/core/functional/list_spec.lua
+++ /dev/null
@@ -1,193 +0,0 @@
-local spy = require "luassert.spy"
-local _ = require "mason.core.functional"
-local Optional = require "mason.core.optional"
-
-describe("functional: list", function()
-    it("should produce list without nils", function()
-        assert.same({ 1, 2, 3, 4 }, _.list_not_nil(nil, 1, 2, nil, 3, nil, 4, nil))
-    end)
-
-    it("makes a shallow copy of a list", function()
-        local list = { "BLUE", { nested = "TABLE" }, "RED" }
-        local list_copy = _.list_copy(list)
-        assert.same({ "BLUE", { nested = "TABLE" }, "RED" }, list_copy)
-        assert.is_not.is_true(list == list_copy)
-        assert.is_true(list[2] == list_copy[2])
-    end)
-
-    it("reverses lists", function()
-        local colors = { "BLUE", "YELLOW", "RED" }
-        assert.same({
-            "RED",
-            "YELLOW",
-            "BLUE",
-        }, _.reverse(colors))
-        -- should not modify in-place
-        assert.same({ "BLUE", "YELLOW", "RED" }, colors)
-    end)
-
-    it("maps over list", function()
-        local colors = { "BLUE", "YELLOW", "RED" }
-        assert.same(
-            {
-                "LIGHT_BLUE",
-                "LIGHT_YELLOW",
-                "LIGHT_RED",
-            },
-            _.map(function(color)
-                return "LIGHT_" .. color
-            end, colors)
-        )
-        -- should not modify in-place
-        assert.same({ "BLUE", "YELLOW", "RED" }, colors)
-    end)
-
-    it("filter_map over list", function()
-        local colors = { "BROWN", "BLUE", "YELLOW", "GREEN", "CYAN" }
-        assert.same(
-            {
-                "BROWN EYES",
-                "BLUE EYES",
-                "GREEN EYES",
-            },
-            _.filter_map(function(color)
-                if _.any_pass({ _.equals "BROWN", _.equals "BLUE", _.equals "GREEN" }, color) then
-                    return Optional.of(("%s EYES"):format(color))
-                else
-                    return Optional.empty()
-                end
-            end, colors)
-        )
-    end)
-
-    it("finds first item that fulfills predicate", function()
-        local predicate = spy.new(function(item)
-            return item == "Waldo"
-        end)
-
-        assert.equal(
-            "Waldo",
-            _.find_first(predicate, {
-                "Where",
-                "On Earth",
-                "Is",
-                "Waldo",
-                "?",
-            })
-        )
-        assert.spy(predicate).was.called(4)
-    end)
-
-    it("determines whether any item in the list fulfills predicate", function()
-        local predicate = spy.new(function(item)
-            return item == "On Earth"
-        end)
-
-        assert.is_true(_.any(predicate, {
-            "Where",
-            "On Earth",
-            "Is",
-            "Waldo",
-            "?",
-        }))
-
-        assert.spy(predicate).was.called(2)
-    end)
-
-    it("should iterate list in .each", function()
-        local list = { "BLUE", "YELLOW", "RED" }
-        local iterate_fn = spy.new()
-        _.each(iterate_fn, list)
-        assert.spy(iterate_fn).was_called(3)
-        assert.spy(iterate_fn).was_called_with("BLUE", 1)
-        assert.spy(iterate_fn).was_called_with("YELLOW", 2)
-        assert.spy(iterate_fn).was_called_with("RED", 3)
-    end)
-
-    it("should concat list tables", function()
-        local list = { "monstera", "tulipa", "carnation" }
-        assert.same({ "monstera", "tulipa", "carnation", "rose", "daisy" }, _.concat(list, { "rose", "daisy" }))
-        assert.same({ "monstera", "tulipa", "carnation" }, list) -- does not mutate list
-    end)
-
-    it("should concat strings", function()
-        assert.equals("FooBar", _.concat("Foo", "Bar"))
-    end)
-
-    it("should zip list into table", function()
-        local fnkey = function() end
-        assert.same({
-            a = "a",
-            [fnkey] = 1,
-        }, _.zip_table({ "a", fnkey }, { "a", 1 }))
-    end)
-
-    it("should get nth item", function()
-        assert.equals("first", _.nth(1, { "first", "middle", "last" }))
-        assert.equals("last", _.nth(-1, { "first", "middle", "last" }))
-        assert.equals("middle", _.nth(-2, { "first", "middle", "last" }))
-        assert.equals("a", _.nth(1, "abc"))
-        assert.equals("c", _.nth(-1, "abc"))
-        assert.equals("b", _.nth(-2, "abc"))
-        assert.is_nil(_.nth(0, { "value" }))
-        assert.equals("", _.nth(0, "abc"))
-    end)
-
-    it("should get length", function()
-        assert.equals(0, _.length {})
-        assert.equals(0, _.length { nil })
-        assert.equals(0, _.length { obj = "doesnt count" })
-        assert.equals(0, _.length "")
-        assert.equals(1, _.length { "" })
-        assert.equals(4, _.length "fire")
-    end)
-
-    it("should sort by comparator", function()
-        local list = {
-            {
-                name = "William",
-            },
-            {
-                name = "Boman",
-            },
-        }
-        assert.same({
-            {
-                name = "Boman",
-            },
-            {
-                name = "William",
-            },
-        }, _.sort_by(_.prop "name", list))
-
-        -- Should not mutate original list
-        assert.same({
-            {
-                name = "William",
-            },
-            {
-                name = "Boman",
-            },
-        }, list)
-    end)
-
-    it("should append to list", function()
-        local list = { "Earth", "Wind" }
-        assert.same({ "Earth", "Wind", { "Fire" } }, _.append({ "Fire" }, list))
-
-        -- Does not mutate original list
-        assert.same({ "Earth", "Wind" }, list)
-    end)
-
-    it("should prepend to list", function()
-        local list = { "Fire" }
-        assert.same({ { "Earth", "Wind" }, "Fire" }, _.prepend({ "Earth", "Wind" }, list))
-
-        -- Does not mutate original list
-        assert.same({ "Fire" }, list)
-    end)
-
-    it("joins lists", function()
-        assert.equals("Hello, John", _.join(", ", { "Hello", "John" }))
-    end)
-end)
diff --git a/tests/core/functional/logic_spec.lua b/tests/core/functional/logic_spec.lua
deleted file mode 100644
index 073ca52c..00000000
--- a/tests/core/functional/logic_spec.lua
+++ /dev/null
@@ -1,57 +0,0 @@
-local spy = require "luassert.spy"
-local _ = require "mason.core.functional"
-
-describe("functional: logic", function()
-    it("should check that all_pass checks that all predicates pass", function()
-        local is_waldo = _.equals "waldo"
-        assert.is_true(_.all_pass { _.T, _.T, is_waldo, _.T } "waldo")
-        assert.is_false(_.all_pass { _.T, _.T, is_waldo, _.F } "waldo")
-        assert.is_false(_.all_pass { _.T, _.T, is_waldo, _.T } "waldina")
-    end)
-
-    it("should check that any_pass checks that any predicates pass", function()
-        local is_waldo = _.equals "waldo"
-        local is_waldina = _.equals "waldina"
-        local is_luigi = _.equals "luigi"
-
-        assert.is_true(_.any_pass { is_waldo, is_waldina } "waldo")
-        assert.is_false(_.any_pass { is_waldina, is_luigi } "waldo")
-        assert.is_true(_.any_pass { is_waldina, is_luigi } "waldina")
-    end)
-
-    it("should branch if_else", function()
-        local a = spy.new()
-        local b = spy.new()
-        _.if_else(_.T, a, b) "a"
-        _.if_else(_.F, a, b) "b"
-        assert.spy(a).was_called(1)
-        assert.spy(a).was_called_with "a"
-        assert.spy(b).was_called(1)
-        assert.spy(b).was_called_with "b"
-    end)
-
-    it("should flip booleans", function()
-        assert.is_true(_.is_not(false))
-        assert.is_false(_.is_not(true))
-    end)
-
-    it("should resolve correct cond", function()
-        local planetary_object = _.cond {
-            {
-                _.equals "Moon!",
-                _.format "to the %s",
-            },
-            {
-                _.equals "World!",
-                _.format "Hello %s",
-            },
-        }
-        assert.equals("Hello World!", planetary_object "World!")
-        assert.equals("to the Moon!", planetary_object "Moon!")
-    end)
-
-    it("should give complements", function()
-        assert.is_true(_.complement(_.is_nil, "not nil"))
-        assert.is_false(_.complement(_.is_nil, nil))
-    end)
-end)
diff --git a/tests/core/functional/number_spec.lua b/tests/core/functional/number_spec.lua
deleted file mode 100644
index f23156fe..00000000
--- a/tests/core/functional/number_spec.lua
+++ /dev/null
@@ -1,50 +0,0 @@
-local _ = require "mason.core.functional"
-
-describe("functional: number", function()
-    it("should negate numbers", function()
-        assert.equals(-42, _.negate(42))
-        assert.equals(42, _.negate(-42))
-    end)
-
-    it("should check numbers greater than value", function()
-        local greater_than_life = _.gt(42)
-        assert.is_false(greater_than_life(0))
-        assert.is_false(greater_than_life(42))
-        assert.is_true(greater_than_life(43))
-    end)
-
-    it("should check numbers greater or equal than value", function()
-        local greater_or_equal_to_life = _.gte(42)
-        assert.is_false(greater_or_equal_to_life(0))
-        assert.is_true(greater_or_equal_to_life(42))
-        assert.is_true(greater_or_equal_to_life(43))
-    end)
-
-    it("should check numbers lower than value", function()
-        local lesser_than_life = _.lt(42)
-        assert.is_true(lesser_than_life(0))
-        assert.is_false(lesser_than_life(42))
-        assert.is_false(lesser_than_life(43))
-    end)
-
-    it("should check numbers lower or equal than value", function()
-        local lesser_or_equal_to_life = _.lte(42)
-        assert.is_true(lesser_or_equal_to_life(0))
-        assert.is_true(lesser_or_equal_to_life(42))
-        assert.is_false(lesser_or_equal_to_life(43))
-    end)
-
-    it("should increment numbers", function()
-        local add_5 = _.inc(5)
-        assert.equals(0, add_5(-5))
-        assert.equals(5, add_5(0))
-        assert.equals(7, add_5(2))
-    end)
-
-    it("should decrement numbers", function()
-        local subtract_5 = _.dec(5)
-        assert.equals(5, subtract_5(10))
-        assert.equals(-5, subtract_5(0))
-        assert.equals(-3, subtract_5(2))
-    end)
-end)
diff --git a/tests/core/functional/relation_spec.lua b/tests/core/functional/relation_spec.lua
deleted file mode 100644
index 4c92ffb5..00000000
--- a/tests/core/functional/relation_spec.lua
+++ /dev/null
@@ -1,36 +0,0 @@
-local _ = require "mason.core.functional"
-
-describe("functional: relation", function()
-    it("should check equality", function()
-        local tbl = {}
-        local is_tbl = _.equals(tbl)
-        local is_a = _.equals "a"
-        local is_42 = _.equals(42)
-
-        assert.is_true(is_tbl(tbl))
-        assert.is_true(is_a "a")
-        assert.is_true(is_42(42))
-        assert.is_false(is_a "b")
-        assert.is_false(is_42(32))
-    end)
-
-    it("should check property equality", function()
-        local fn_key = function() end
-        local tbl = { a = "a", b = "b", number = 42, [fn_key] = "fun" }
-        assert.is_true(_.prop_eq("a", "a", tbl))
-        assert.is_true(_.prop_eq(fn_key, "fun", tbl))
-        assert.is_true(_.prop_eq(fn_key) "fun"(tbl))
-    end)
-
-    it("should check whether property satisfies predicate", function()
-        local obj = {
-            low = 0,
-            med = 10,
-            high = 15,
-        }
-
-        assert.is_false(_.prop_satisfies(_.gt(10), "low", obj))
-        assert.is_false(_.prop_satisfies(_.gt(10), "med")(obj))
-        assert.is_true(_.prop_satisfies(_.gt(10)) "high"(obj))
-    end)
-end)
diff --git a/tests/core/functional/string_spec.lua b/tests/core/functional/string_spec.lua
deleted file mode 100644
index 4f9f4722..00000000
--- a/tests/core/functional/string_spec.lua
+++ /dev/null
@@ -1,43 +0,0 @@
-local _ = require "mason.core.functional"
-
-describe("functional: string", function()
-    it("matches string patterns", function()
-        assert.is_true(_.matches("foo", "foo"))
-        assert.is_true(_.matches("bar", "foobarbaz"))
-        assert.is_true(_.matches("ba+r", "foobaaaaaaarbaz"))
-
-        assert.is_false(_.matches("ba+r", "foobharbaz"))
-        assert.is_false(_.matches("bar", "foobaz"))
-    end)
-
-    it("should format strings", function()
-        assert.equals("Hello World!", _.format("%s", "Hello World!"))
-        assert.equals("special manouvers", _.format("%s manouvers", "special"))
-    end)
-
-    it("should split strings", function()
-        assert.same({ "This", "is", "a", "sentence" }, _.split("%s", "This is a sentence"))
-        assert.same({ "This", "is", "a", "sentence" }, _.split("|", "This|is|a|sentence"))
-    end)
-
-    it("should gsub strings", function()
-        assert.same("predator", _.gsub("^apex%s*", "", "apex predator"))
-    end)
-
-    it("should dedent strings", function()
-        assert.equals(
-            [[Lorem
-Ipsum
-    Dolor
-  Sit
- Amet]],
-            _.dedent [[
-    Lorem
-    Ipsum
-        Dolor
-      Sit
-     Amet
-]]
-        )
-    end)
-end)
diff --git a/tests/core/functional/table_spec.lua b/tests/core/functional/table_spec.lua
deleted file mode 100644
index b10527f1..00000000
--- a/tests/core/functional/table_spec.lua
+++ /dev/null
@@ -1,51 +0,0 @@
-local _ = require "mason.core.functional"
-
-describe("functional: table", function()
-    it("retrieves property of table", function()
-        assert.equals("hello", _.prop("a", { a = "hello" }))
-    end)
-
-    it("picks properties of table", function()
-        local function fn() end
-        assert.same(
-            {
-                ["key1"] = 1,
-                [fn] = 2,
-            },
-            _.pick({ "key1", fn }, {
-                ["key1"] = 1,
-                [fn] = 2,
-                [3] = 3,
-            })
-        )
-    end)
-
-    it("converts table to pairs", function()
-        assert.same(
-            _.sort_by(_.nth(1), {
-                {
-                    "skies",
-                    "cloudy",
-                },
-                {
-                    "temperature",
-                    "20°",
-                },
-            }),
-            _.sort_by(_.nth(1), _.to_pairs { skies = "cloudy", temperature = "20°" })
-        )
-    end)
-
-    it("should invert tables", function()
-        assert.same(
-            {
-                val1 = "key1",
-                val2 = "key2",
-            },
-            _.invert {
-                key1 = "val1",
-                key2 = "val2",
-            }
-        )
-    end)
-end)
diff --git a/tests/core/functional/type_spec.lua b/tests/core/functional/type_spec.lua
deleted file mode 100644
index 8e8068df..00000000
--- a/tests/core/functional/type_spec.lua
+++ /dev/null
@@ -1,26 +0,0 @@
-local _ = require "mason.core.functional"
-
-describe("functional: type", function()
-    it("should check nil value", function()
-        assert.is_true(_.is_nil(nil))
-        assert.is_false(_.is_nil(1))
-        assert.is_false(_.is_nil {})
-        assert.is_false(_.is_nil(function() end))
-    end)
-
-    it("should check types", function()
-        local is_fun = _.is "function"
-        local is_string = _.is "string"
-        local is_number = _.is "number"
-        local is_boolean = _.is "boolean"
-
-        assert.is_true(is_fun(function() end))
-        assert.is_false(is_fun(1))
-        assert.is_true(is_string "")
-        assert.is_false(is_string(1))
-        assert.is_true(is_number(1))
-        assert.is_false(is_number "")
-        assert.is_true(is_boolean(true))
-        assert.is_false(is_boolean(1))
-    end)
-end)