# General Lua Libraries for Lua 5.1, 5.2 & 5.3
# Copyright (C) 2011-2018 stdlib authors

before: |
  base_module = 'io'
  this_module = 'std.io'
  global_table = '_G'

  extend_base = {'catdir', 'catfile', 'die', 'dirname',
                 'process_files', 'readlines', 'shell', 'slurp',
                 'splitdir', 'warn', 'writelines'}

  dirsep = string.match(package.config, '^([^\n]+)\n')

  M = require(this_module)


specify std.io:
- 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 io table:
        expect(show_apis {added_to=base_module, by=this_module}).
           to_equal {}
    - it contains apis from the core io 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 io table:
        expect(show_apis {added_to=base_module, by='std'}).
           to_equal {}


- describe catdir:
  - before: |
      f = M.catdir

  - context with bad arguments:
      badargs.diagnose(f, 'std.io.catdir(string*)')

  - it treats initial empty string as root directory:
      expect(f('')).to_be(dirsep)
      expect(f('', '')).to_be(dirsep)
      expect(f('', 'root')).to_be(dirsep .. 'root')
  - it returns a single argument unchanged:
      expect(f('hello')).to_be 'hello'
  - it joins multiple arguments with platform directory separator:
      expect(f('one', 'two')).to_be('one' .. dirsep .. 'two')
      expect(f('1', '2', '3', '4', '5')).
         to_be(table.concat({'1', '2', '3', '4', '5'}, dirsep))


- describe catfile:
  - before:
      f = M.catfile

  - context with bad arguments:
      badargs.diagnose(f, 'std.io.catfile(string*)')

  - it treats initial empty string as root directory:
      expect(f('', '')).to_be(dirsep)
      expect(f('', 'root')).to_be(dirsep .. 'root')
  - it returns a single argument unchanged:
      expect(f('')).to_be ''
      expect(f('hello')).to_be 'hello'
  - it joins multiple arguments with platform directory separator:
      expect(f('one', 'two')).to_be('one' .. dirsep .. 'two')
      expect(f('1', '2', '3', '4', '5')).
         to_be(table.concat({'1', '2', '3', '4', '5'}, dirsep))


- describe die:
  - before: |
      script = [[require 'std.io'.die "By 'eck!"]]

      f = M.die

  - context with bad arguments:
      badargs.diagnose(f, 'std.io.die(string, ?any*)')

  - it outputs a message to stderr: |
      expect(luaproc(script)).to_fail_while_matching ": By 'eck!\n"
  - it ignores `prog.line` without `prog.file` or `prog.name`: |
      script = [[prog = {line=125};]] .. script
      expect(luaproc(script)).to_fail_while_matching ": By 'eck!\n"
  - it ignores `opts.line` without `opts.program`: |
      script = [[opts = {line=99};]] .. script
      expect(luaproc(script)).to_fail_while_matching ": By 'eck!\n"
  - it prefixes `prog.name` if any: |
      script = [[prog = {name='name'};]] .. script
      expect(luaproc(script)).to_fail_while_matching ": name: By 'eck!\n"
  - it appends `prog.line` if any, to `prog.name`: |
      script = [[prog = {line=125, name='name'};]] .. script
      expect(luaproc(script)).to_fail_while_matching ": name:125: By 'eck!\n"
  - it prefixes `prog.file` if any: |
      script = [[prog = {file='file'};]] .. script
      expect(luaproc(script)).to_fail_while_matching ": file: By 'eck!\n"
  - it appends `prog.line` if any, to `prog.name`: |
      script = [[prog = {file='file', line=125};]] .. script
      expect(luaproc(script)).to_fail_while_matching ": file:125: By 'eck!\n"
  - it prefers `prog.name` to `prog.file` or `opts.program`: |
      script = [[
         prog = {file='file', name='name'}
         opts = {program='program'}
      ]] .. script
      expect(luaproc(script)).to_fail_while_matching ": name: By 'eck!\n"
  - it appends `prog.line` if any to `prog.name` over anything else: |
      script = [[
         prog = {file='file', line=125, name='name'}
         opts = {line=99, program='program'}
      ]] .. script
      expect(luaproc(script)).to_fail_while_matching ": name:125: By 'eck!\n"
  - it prefers `prog.file` to `opts.program`: |
      script = [[
         prog = {file='file'}; opts = {program='program'}
      ]] .. script
      expect(luaproc(script)).to_fail_while_matching ": file: By 'eck!\n"
  - it appends `prog.line` if any to `prog.file` over using `opts`: |
      script = [[
         prog = {file='file', line=125}
         opts = {line=99, program='program'}
      ]] .. script
      expect(luaproc(script)).to_fail_while_matching ": file:125: By 'eck!\n"
  - it prefixes `opts.program` if any: |
      script = [[opts = {program='program'};]] .. script
      expect(luaproc(script)).to_fail_while_matching ": program: By 'eck!\n"
  - it appends `opts.line` if any, to `opts.program`: |
      script = [[opts = {line=99, program='program'};]] .. script
      expect(luaproc(script)).to_fail_while_matching ": program:99: By 'eck!\n"


- describe dirname:
  - before:
      f = M.dirname
      path = table.concat({'', 'one', 'two', 'three'}, dirsep)

  - context with bad arguments:
      badargs.diagnose(f, 'std.io.dirname(string)')

  - it removes final separator and following:
      expect(f(path)).to_be(table.concat({'', 'one', 'two'}, dirsep))


- describe process_files:
  - before:
      name = 'Makefile'
      names = {'LICENSE.md', 'Makefile', 'README.md'}
      ascript = [[
         require 'std.io'.process_files(function(a)
            print(a)
         end)
      ]]
      lscript = [[
         require 'std.io'.process_files('=print(_1)')
      ]]
      iscript = [[
         require 'std.io'.process_files(function(_, i)
            print(i)
         end)
      ]]
      catscript = [[
         require 'std.io'.process_files(function()
            io.write(io.input():read '*a')
         end)
      ]]

      f = M.process_files

  - context with bad arguments: |
      badargs.diagnose(f, 'std.io.process_files(func)')

      examples {
         ["it diagnoses non-file 'arg' elements"] = function()
            expect(luaproc(ascript, 'not-an-existing-file')).to_contain_error.any_of {
               "cannot open file 'not-an-existing-file'",            -- Lua 5.2
               "bad argument #1 to 'input' (not-an-existing-file:",  -- Lua 5.1
            }
         end
      }

  - it defaults to `-` if no arguments were passed:
      expect(luaproc(ascript)).to_output '-\n'
  - it iterates over arguments with supplied function:
      expect(luaproc(ascript, name)).to_output(name .. '\n')
      expect(luaproc(ascript, names)).
         to_output(table.concat(names, '\n') .. '\n')
  - it passes argument numbers to supplied function:
      expect(luaproc(iscript, names)).to_output '1\n2\n3\n'
  - it sets each file argument as the default input:
      expect(luaproc(catscript, name)).to_output(concat_file_content(name))
      expect(luaproc(catscript, names)).
         to_output(concat_file_content(unpack(names)))
  - it processes io.stdin if no arguments were passed:
      ## FIXME: where does that closing newline come from??
      expect(luaproc(catscript, nil, 'some\nlines\nof input')).to_output 'some\nlines\nof input\n'
  - it processes io.stdin for `-` argument:
      ## FIXME: where does that closing newline come from??
      expect(luaproc(catscript, '-', 'some\nlines\nof input')).to_output 'some\nlines\nof input\n'


- describe readlines:
  - before: |
      name = 'Makefile'
      h = io.open(name)
      lines = {}
      for l in h:lines() do
         lines[#lines + 1] = l
      end
      h:close()

      defaultin = io.input()

      f, badarg = init(M, this_module,  'readlines')
  - after:
      if io.type(defaultin) ~= 'closed file' then
         io.input(defaultin)
      end

  - context with bad arguments: |
      badargs.diagnose(f, 'std.io.readlines(?file|string)')

      if have_typecheck then
         examples {
            ['it diagnoses non-existent file'] = function()
               expect(f 'not-an-existing-file').
                  to_raise "bad argument #1 to 'std.io.readlines'(" -- system dependent error message
            end
         }
         closed = io.open(name, 'r') closed:close()
         examples {
            ['it diagnoses closed file argument'] = function()
               expect(f(closed)).to_raise(badarg(1, '?file|string', 'closed file'))
            end
         }
      end

  - it closes file handle upon completion:
      h = io.open(name)
      expect(io.type(h)).not_to_be 'closed file'
      f(h)
      expect(io.type(h)).to_be 'closed file'
  - it reads lines from an existing named file:
      expect(f(name)).to_equal(lines)
  - it reads lines from an open file handle:
      expect(f(io.open(name))).to_equal(lines)
  - it reads from default input stream with no arguments:
      io.input(name)
      expect(f()).to_equal(lines)


- describe shell:
  - before:
      f = M.shell

  - context with bad arguments:
      badargs.diagnose(f, 'std.io.shell(string)')

  - it returns the output from a shell command string:
      expect(f [[printf '%s\n' 'foo' 'bar']]).to_be 'foo\nbar\n'


- describe slurp:
  - before: |
      name = 'Makefile'
      h = io.open(name)
      content = h:read '*a'
      h:close()

      defaultin = io.input()
      f, badarg = init(M, this_module,  'slurp')
  - after:
      if io.type(defaultin) ~= 'closed file' then
         io.input(defaultin)
      end

  - context with bad arguments: |
      badargs.diagnose(f, 'std.io.slurp(?file|string)')

      if have_typecheck then
         examples {
            ['it diagnoses non-existent file'] = function()
               expect(f 'not-an-existing-file').
                  to_raise "bad argument #1 to 'std.io.slurp'(" -- system dependent error message
            end
         }
         closed = io.open(name, 'r') closed:close()
         examples {
            ['it diagnoses closed file argument'] = function()
               expect(f(closed)).to_raise(badarg(1, '?file|string', 'closed file'))
            end
         }
      end

  - it reads content from an existing named file:
      expect(f(name)).to_be(content)
  - it reads content from an open file handle:
      expect(f(io.open(name))).to_be(content)
  - it closes file handle upon completion:
      h = io.open(name)
      expect(io.type(h)).not_to_be 'closed file'
      f(h)
      expect(io.type(h)).to_be 'closed file'
  - it reads from default input stream with no arguments:
      io.input(name)
      expect(f()).to_be(content)


- describe splitdir:
  - before:
      f = M.splitdir

  - context with bad arguments:
      badargs.diagnose(f, 'std.io.splitdir(string)')

  - it returns a filename as a one element list:
      expect(f('hello')).to_equal {'hello'}
  - it splits root directory in two empty elements:
      expect(f(dirsep)).to_equal {'', ''}
  - it returns initial empty string for absolute path:
      expect(f(dirsep .. 'root')).to_equal {'', 'root'}
  - it returns multiple components split at platform directory separator:
      expect(f('one' .. dirsep .. 'two')).to_equal {'one', 'two'}
      expect(f(table.concat({'1', '2', '3', '4', '5'}, dirsep))).
         to_equal {'1', '2', '3', '4', '5'}


- describe warn:
  - before:
      script = [[require 'std.io'.warn 'Ayup!']]
      f = M.warn

  - context with bad arguments:
      badargs.diagnose(f, 'std.io.warn(string, ?any*)')

  - it outputs a message to stderr:
      expect(luaproc(script)).to_output_error 'Ayup!\n'
  - it ignores `prog.line` without `prog.file`, `prog.name` or `opts.program`:
      script = [[prog = {line=125};]] .. script
      expect(luaproc(script)).to_output_error 'Ayup!\n'
  - it prefixes `prog.name` if any: |
      script = [[prog = {name='name'};]] .. script
      expect(luaproc(script)).to_output_error 'name: Ayup!\n'
  - it appends `prog.line` if any, to `prog.name`: |
      script = [[prog = {line=125, name='name'};]] .. script
      expect(luaproc(script)).to_output_error 'name:125: Ayup!\n'
  - it prefixes `prog.file` if any: |
      script = [[prog = {file='file'};]] .. script
      expect(luaproc(script)).to_output_error 'file: Ayup!\n'
  - it appends `prog.line` if any, to `prog.name`: |
      script = [[prog = {file='file', line=125};]] .. script
      expect(luaproc(script)).to_output_error 'file:125: Ayup!\n'
  - it prefers `prog.name` to `prog.file` or `opts.program`: |
      script = [[
         prog = {file='file', name='name'}
         opts = {program='program'}
      ]] .. script
      expect(luaproc(script)).to_output_error 'name: Ayup!\n'
  - it appends `prog.line` if any to `prog.name` over anything else: |
      script = [[
         prog = {file='file', line=125, name='name'}
         opts = {line=99, program='program'}
      ]] .. script
      expect(luaproc(script)).to_output_error 'name:125: Ayup!\n'
  - it prefers `prog.file` to `opts.program`: |
      script = [[
         prog = {file='file'}; opts = {program='program'}
      ]] .. script
      expect(luaproc(script)).to_output_error 'file: Ayup!\n'
  - it appends `prog.line` if any to `prog.file` over using `opts`: |
      script = [[
         prog = {file='file', line=125}
         opts = {line=99, program='program'}
      ]] .. script
      expect(luaproc(script)).to_output_error 'file:125: Ayup!\n'
  - it prefixes `opts.program` if any: |
      script = [[opts = {program='program'};]] .. script
      expect(luaproc(script)).to_output_error 'program: Ayup!\n'
  - it appends `opts.line` if any, to `opts.program`: |
      script = [[opts = {line=99, program='program'};]] .. script
      expect(luaproc(script)).to_output_error 'program:99: Ayup!\n'


- describe writelines:
  - before: |
      name = os.tmpname()
      h = io.open(name, 'w')
      lines = M.readlines(io.open 'Makefile')

      defaultout = io.output()
      f, badarg = init(M, this_module,  'writelines')
  - after:
      if io.type(defaultout) ~= 'closed file' then
         io.output(defaultout)
      end
      h:close()
      os.remove(name)

  - context with bad arguments:
    - 'it diagnoses argument #1 type not FILE*, string, number or nil':
        if have_typecheck then
           expect(f(false)).to_raise(badarg(1, '?file|string|number', 'boolean'))
        end
    - 'it diagnoses argument #2 type not string, number or nil':
        if have_typecheck then
           expect(f(1, false)).to_raise(badarg(2, 'string|number', 'boolean'))
        end
    - 'it diagnoses argument #3 type not string, number or nil':
        if have_typecheck then
           expect(f(1, 2, false)).to_raise(badarg(3, 'string|number', 'boolean'))
        end
    - it diagnoses closed file argument: |
        closed = io.open(name, 'r') closed:close()
        if have_typecheck then
           expect(f(closed)).to_raise(badarg(1, '?file|string|number', 'closed file'))
        end

  - it does not close the file handle upon completion:
      expect(io.type(h)).not_to_be 'closed file'
      f(h, 'foo')
      expect(io.type(h)).not_to_be 'closed file'
  - it writes lines to an open file handle:
      f(h, unpack(lines))
      h:flush()
      expect(M.readlines(io.open(name))).to_equal(lines)
  - it accepts number valued arguments:
      f(h, 1, 2, 3)
      h:flush()
      expect(M.readlines(io.open(name))).to_equal {'1', '2', '3'}
  - it writes to default output stream with non-file first argument:
      io.output(h)
      f(unpack(lines))
      h:flush()
      expect(M.readlines(io.open(name))).to_equal(lines)