1 files changed, 202 insertions, 0 deletions
diff --git a/Data/BuiltIn/Libraries/lua-stdlib/spec/package_spec.yaml b/Data/BuiltIn/Libraries/lua-stdlib/spec/package_spec.yaml
new file mode 100644
index 0000000..23ce961
--- /dev/null
+++ b/Data/BuiltIn/Libraries/lua-stdlib/spec/package_spec.yaml
@@ -0,0 +1,202 @@
+# General Lua Libraries for Lua 5.1, 5.2 & 5.3
+# Copyright (C) 2011-2018 stdlib authors
+
+before: |
+  base_module = 'package'
+  this_module = 'std.package'
+  global_table = '_G'
+
+  extend_base = {'find', 'insert', 'mappath', 'normalize', 'remove'}
+
+  M = require(this_module)
+
+  path = M.normalize('begin', 'middle', 'end')
+
+  function catfile(...)
+     return table.concat({...}, M.dirsep)
+  end
+  function catpath(...)
+     return table.concat({...}, M.pathsep)
+  end
+
+
+specify std.package:
+- context when required:
+  - context by name:
+    - it does not touch the global table:
+        expect(show_apis {added_to=global_table, by=this_module}).
+           to_equal {}
+    - it does not touch the core package table:
+        expect(show_apis {added_to=base_module, by=this_module}).
+           to_equal {}
+    - it contains apis from the core package table:
+        expect(show_apis {from=base_module, not_in=this_module}).
+           to_contain.a_permutation_of(extend_base)
+
+  - context via the std module:
+    - it does not touch the global table:
+        expect(show_apis {added_to=global_table, by='std'}).
+           to_equal {}
+    - it does not touch the core package table:
+        expect(show_apis {added_to=base_module, by='std'}).
+           to_equal {}
+
+
+- describe find:
+  - before: |
+      path = table.concat({'begin', 'm%ddl.', 'end'}, M.pathsep)
+
+      f = M.find
+
+  - context with bad arguments:
+      badargs.diagnose(f, 'std.package.find(string, string, ?int, ?boolean|:plain)')
+
+  - it returns nil for unmatched element:
+      expect(f(path, 'unmatchable')).to_be(nil)
+  - it returns the element index for a matched element:
+      expect(f(path, 'end')).to_be(3)
+  - it returns the element text for a matched element:
+      i, element = f(path, 'e.*n')
+      expect({i, element}).to_equal {1, 'begin'}
+  - it accepts a search start element argument:
+      i, element = f(path, 'e.*n', 2)
+      expect({i, element}).to_equal {3, 'end'}
+  - it works with plain text search strings:
+      expect(f(path, 'm%ddl.')).to_be(nil)
+      i, element = f(path, '%ddl.', 1, ':plain')
+      expect({i, element}).to_equal {2, 'm%ddl.'}
+
+
+- describe insert:
+  - before:
+      f = M.insert
+
+  - context with bad arguments:
+      badargs.diagnose(f, 'std.package.insert(string, [int], string)')
+
+  - it appends by default:
+      expect(f(path, 'new')).
+         to_be(M.normalize('begin', 'middle', 'end', 'new'))
+  - it prepends with pos set to 1:
+      expect(f(path, 1, 'new')).
+         to_be(M.normalize('new', 'begin', 'middle', 'end'))
+  - it can insert in the middle too:
+      expect(f(path, 2, 'new')).
+         to_be(M.normalize('begin', 'new', 'middle', 'end'))
+      expect(f(path, 3, 'new')).
+         to_be(M.normalize('begin', 'middle', 'new', 'end'))
+  - it normalizes the returned path:
+      path = table.concat({'begin', 'middle', 'end'}, M.pathsep)
+      expect(f(path, 'new')).
+         to_be(M.normalize('begin', 'middle', 'end', 'new'))
+      expect(f(path, 1, './x/../end')).
+         to_be(M.normalize('end', 'begin', 'middle'))
+
+
+- describe mappath:
+  - before: |
+      expected = require 'std.string'.split(path, M.pathsep)
+
+      f = M.mappath
+
+  - context with bad arguments:
+      badargs.diagnose(f, 'std.package.mappath(string, function, ?any*)')
+
+  - it calls a function with each path element:
+      t = {}
+      f(path, function(e)
+         t[#t + 1] = e
+      end)
+      expect(t).to_equal(expected)
+  - it passes additional arguments through: |
+      reversed = {}
+      for i = #expected, 1, -1 do
+         table.insert(reversed, expected[i])
+      end
+      t = {}
+      f(path, function(e, pos)
+         table.insert(t, pos, e)
+      end, 1)
+      expect(t).to_equal(reversed)
+
+
+- describe normalize:
+  - before:
+      f = M.normalize
+
+  - context with bad arguments:
+      badargs.diagnose(f, 'std.package.normalize(string*)')
+
+  - context with a single element:
+    - it strips redundant . directories:
+        expect(f './x/./y/.').to_be(catfile('.', 'x', 'y'))
+    - it strips redundant .. directories:
+        expect(f '../x/../y/z/..').to_be(catfile('..', 'y'))
+        expect(f '../x/../y/z/..').to_be(catfile('..', 'y'))
+        expect(f '../../x/../y/z/..').to_be(catfile('..', '..', 'y'))
+        expect(f '../../x/../y/./..').to_be(catfile('..', '..'))
+        expect(f '../../w/x/../../y/z/..').to_be(catfile('..', '..', 'y'))
+        expect(f '../../w/./../.././z/..').to_be(catfile('..', '..', '..'))
+    - it leaves leading .. directories unmolested:
+        expect(f '../../1').to_be(catfile('..', '..', '1'))
+        expect(f './../../1').to_be(catfile('..', '..', '1'))
+    - it normalizes / to platform dirsep:
+        expect(f '/foo/bar').to_be(catfile('', 'foo', 'bar'))
+    - it normalizes ? to platform pathmark:
+        expect(f '?.lua').
+           to_be(catfile('.', M.pathmark .. '.lua'))
+    - it strips redundant trailing /:
+        expect(f '/foo/bar/').to_be(catfile('', 'foo', 'bar'))
+    - it inserts missing ./ for relative paths:
+        for _, path in ipairs {'x', './x'} do
+           expect(f(path)).to_be(catfile('.', 'x'))
+        end
+  - context with multiple elements:
+    - it strips redundant . directories:
+        expect(f('./x/./y/.', 'x')).
+           to_be(catpath(catfile('.', 'x', 'y'), catfile('.', 'x')))
+    - it strips redundant .. directories:
+        expect(f('../x/../y/z/..', 'x')).
+           to_be(catpath(catfile('..', 'y'), catfile('.', 'x')))
+    - it normalizes / to platform dirsep:
+        expect(f('/foo/bar', 'x')).
+           to_be(catpath(catfile('', 'foo', 'bar'), catfile('.', 'x')))
+    - it normalizes ? to platform pathmark:
+        expect(f('?.lua', 'x')).
+           to_be(catpath(catfile('.', M.pathmark .. '.lua'), catfile('.', 'x')))
+    - it strips redundant trailing /:
+        expect(f('/foo/bar/', 'x')).
+           to_be(catpath(catfile('', 'foo', 'bar'), catfile('.', 'x')))
+    - it inserts missing ./ for relative paths:
+        for _, path in ipairs {'x', './x'} do
+           expect(f(path, 'a')).
+              to_be(catpath(catfile('.', 'x'), catfile('.', 'a')))
+        end
+  - it eliminates all but the first equivalent elements:
+      expect(f(catpath('1', 'x', '2', './x', './2', './x/../x'))).
+         to_be(catpath('./1', './x', './2'))
+
+
+- describe remove:
+  - before:
+      f = M.remove
+
+  - context with bad arguments:
+      badargs.diagnose(f, 'std.package.remove(string, ?int)')
+
+  - it removes the last item by default:
+      expect(f(path)).to_be(M.normalize('begin', 'middle'))
+  - it pops the first item with pos set to 1:
+      expect(f(path, 1)).to_be(M.normalize('middle', 'end'))
+  - it can remove from the middle too:
+      expect(f(path, 2)).to_be(M.normalize('begin', 'end'))
+  - it does not normalize the returned path:
+      path = table.concat({'begin', 'middle', 'end'}, M.pathsep)
+      expect(f(path)).
+         to_be(table.concat({'begin', 'middle'}, M.pathsep))
+
+
+- it splits package.config up:
+    expect(string.format('%s\n%s\n%s\n%s\n%s\n',
+       M.dirsep, M.pathsep, M.pathmark, M.execdir, M.igmark)
+    ).to_contain(package.config)