tty-command 0.9.0 → 0.10.0

data/spec/unit/printers/quiet_spec.rb

@@ -1,71 +0,0 @@
-# encoding: utf-8
-
-RSpec.describe TTY::Command::Printers::Quiet do
-  let(:output) { StringIO.new }
-
-  it "doesn't print command start or exit" do
-    printer = TTY::Command::Printers::Quiet.new(output)
-    cmd = TTY::Command::Cmd.new("echo hello")
-
-    printer.print_command_start(cmd)
-    printer.print_command_exit(cmd, 0)
-    output.rewind
-
-    expect(output.string).to be_empty
-  end
-
-  it "prints command stdout data" do
-    printer = TTY::Command::Printers::Quiet.new(output)
-    cmd = TTY::Command::Cmd.new("echo hello")
-
-    printer.print_command_out_data(cmd, 'hello', 'world')
-    output.rewind
-
-    expect(output.string).to eq("hello world")
-  end
-
-  it "prints command stderr data" do
-    printer = TTY::Command::Printers::Quiet.new(output)
-    cmd = TTY::Command::Cmd.new("echo hello")
-
-    printer.print_command_err_data(cmd, 'hello', 'world')
-    output.rewind
-
-    expect(output.string).to eq("hello world")
-  end
-
-  it "doesn't print output on success when only_output_on_error is true" do
-    zero_exit = fixtures_path('zero_exit')
-    printer = TTY::Command::Printers::Quiet
-    cmd = TTY::Command.new(output: output, printer: printer)
-
-    cmd.run!(:ruby, zero_exit, only_output_on_error: true)
-    cmd.run!(:ruby, zero_exit)
-
-    output.rewind
-
-    lines = output.readlines.map(&:chomp)
-
-    expect(lines).to eq([
-      "yess"
-    ])
-  end
-
-  it "prints output on error when only_output_on_error is true" do
-    non_zero_exit = fixtures_path('non_zero_exit')
-    printer = TTY::Command::Printers::Quiet
-    cmd = TTY::Command.new(output: output, printer: printer)
-
-    cmd.run!(:ruby, non_zero_exit, only_output_on_error: true)
-    cmd.run!(:ruby, non_zero_exit)
-
-    output.rewind
-
-    lines = output.readlines.map(&:chomp)
-
-    expect(lines).to eq([
-      "nooo",
-      "nooo"
-    ])
-  end
-end

data/spec/unit/pty_spec.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Command, ':pty' do
-  it "executes command in pseudo terminal mode as global option",
-     unless: RSpec::Support::OS.windows? do
-
-    color_cli = fixtures_path('color')
-    output = StringIO.new
-    cmd = TTY::Command.new(output: output, pty: true)
-
-    out, err = cmd.run(color_cli)
-
-    expect(err).to eq('')
-    expect(out).to eq("\e[32mcolored\e[0m\n")
-  end
-
-  it "executes command in pseudo terminal mode as command option",
-      unless: RSpec::Support::OS.windows? do
-
-    color_cli = fixtures_path('color')
-    output = StringIO.new
-    cmd = TTY::Command.new(output: output)
-
-    out, err = cmd.run(color_cli, pty: true)
-
-    expect(err).to eq('')
-    expect(out).to eq("\e[32mcolored\e[0m\n")
-  end
-
-  it "logs phased output in pseudo terminal mode",
-      unless: RSpec::Support::OS.windows? do
-
-    phased_output = fixtures_path('phased_output')
-    uuid= 'xxxx'
-    allow(SecureRandom).to receive(:uuid).and_return(uuid)
-    output = StringIO.new
-    cmd = TTY::Command.new(output: output)
-
-    out, err = cmd.run("ruby #{phased_output}", pty: true)
-
-    expect(out).to eq('.' * 10)
-    expect(err).to eq('')
-
-    output.rewind
-    lines = output.readlines
-    lines.last.gsub!(/\d+\.\d+/, 'x')
-    expect(lines).to eq([
-      "[\e[32m#{uuid}\e[0m] Running \e[33;1mruby #{phased_output}\e[0m\n",
-      "[\e[32m#{uuid}\e[0m] \t.\n",
-      "[\e[32m#{uuid}\e[0m] \t.\n",
-      "[\e[32m#{uuid}\e[0m] \t.\n",
-      "[\e[32m#{uuid}\e[0m] \t.\n",
-      "[\e[32m#{uuid}\e[0m] \t.\n",
-      "[\e[32m#{uuid}\e[0m] \t.\n",
-      "[\e[32m#{uuid}\e[0m] \t.\n",
-      "[\e[32m#{uuid}\e[0m] \t.\n",
-      "[\e[32m#{uuid}\e[0m] \t.\n",
-      "[\e[32m#{uuid}\e[0m] \t.\n",
-      "[\e[32m#{uuid}\e[0m] Finished in x seconds with exit status 0 (\e[32;1msuccessful\e[0m)\n"
-    ])
-  end
-end

data/spec/unit/redirect_spec.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Command, 'redirect' do
-  it "accepts standard shell redirects" do
-    output = StringIO.new
-    command = TTY::Command.new(output: output)
-
-    out, err = command.run("echo hello 1>& 2")
-
-    expect(out).to eq("")
-    expect(err).to match(%r{hello\s*\n})
-  end
-
-  it "redirects :out -> :err" do
-    output = StringIO.new
-    cmd = TTY::Command.new(output: output)
-
-    out, err = cmd.run("echo hello", :out => :err)
-
-    expect(out).to be_empty
-    expect(err.chomp).to eq("hello")
-  end
-
-  it "redirects :stdout -> :stderr" do
-    output = StringIO.new
-    cmd = TTY::Command.new(output: output)
-
-    out, err = cmd.run("echo hello", :stdout => :stderr)
-
-    expect(out).to be_empty
-    expect(err.chomp).to eq("hello")
-  end
-
-  it "redirects 1 -> 2" do
-    output = StringIO.new
-    cmd = TTY::Command.new(output: output)
-
-    out, err = cmd.run("echo hello", 1 => 2)
-
-    expect(out).to be_empty
-    expect(err.chomp).to eq("hello")
-  end
-
-  it "redirects STDOUT -> :err" do
-    output = StringIO.new
-    cmd = TTY::Command.new(output: output)
-
-    out, err = cmd.run("echo hello", STDOUT => :err)
-
-    expect(out).to be_empty
-    expect(err.chomp).to eq("hello")
-  end
-
-  it "redirects STDOUT -> '/dev/null" do
-    output = StringIO.new
-    cmd = TTY::Command.new(output: output)
-
-    out, _ = cmd.run('echo hello', :out => IO::NULL)
-
-    expect(out).to eq("")
-  end
-
-  it "redirects to a file", type: :cli do
-    file = tmp_path('log')
-    output = StringIO.new
-    cmd = TTY::Command.new(output: output)
-
-    out, err = cmd.run('echo hello', :out => file)
-
-    expect(out).to be_empty
-    expect(err).to be_empty
-    expect(File.read(file)).to eq("hello\n")
-  end
-
-  it "redirects to a file as an array value", type: :cli do
-    file = tmp_path('log')
-    output = StringIO.new
-    cmd = TTY::Command.new(output: output)
-
-    expect(File.writable?(file)).to eq(false)
-    out, err = cmd.run('echo hello', :out => [file, 'w', 0600])
-
-    expect(out).to be_empty
-    expect(err).to be_empty
-    expect(File.read(file)).to eq("hello\n")
-    expect(File.writable?(file)).to eq(true)
-    unless RSpec::Support::OS.windows?
-      expect(File.stat(file).mode.to_s(8)[2..5]).to eq('0600')
-    end
-  end
-
-  it "redirects multiple fds to a file", type: :cli do
-    file = tmp_path('log')
-    output = StringIO.new
-    cmd = TTY::Command.new(output: output)
-
-    out, err = cmd.run('echo hello', [:out, :err] => file)
-
-    expect(out).to be_empty
-    expect(err).to be_empty
-    expect(File.read(file)).to eq("hello\n")
-  end
-end

data/spec/unit/result_spec.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Command::Result do
-  it "exits successfully" do
-    result = TTY::Command::Result.new(0, '', '')
-    expect(result.exited?).to eq(true)
-    expect(result.success?).to eq(true)
-  end
-
-  it "exist with non-zero code" do
-    result = TTY::Command::Result.new(127, '', '')
-    expect(result.exited?).to eq(true)
-    expect(result.success?).to eq(false)
-  end
-
-  it "accesses exit code" do
-    result = TTY::Command::Result.new(127, '', '')
-    expect(result.to_i).to eq(127)
-    expect(result.to_s).to eq('127')
-  end
-
-  it "provides runtime" do
-    result = TTY::Command::Result.new(0, '', '', 5.4)
-    expect(result.runtime).to eq(5.4)
-  end
-
-  it "doesn't exit" do
-    result = TTY::Command::Result.new(nil, '', '')
-    expect(result.exited?).to eq(false)
-    expect(result.success?).to eq(false)
-  end
-
-  it "reads stdout" do
-    result = TTY::Command::Result.new(0, 'foo', '')
-    expect(result.out).to eq('foo')
-  end
-
-  it "isn't equivalent with another object" do
-    result = TTY::Command::Result.new(0, '', '')
-    expect(result).to_not eq(:other)
-  end
-
-  it "is the same with equivalent object" do
-    result_foo = TTY::Command::Result.new(0, 'foo', 'bar')
-    result_bar = TTY::Command::Result.new(0, 'foo', 'bar')
-    expect(result_foo).to eq(result_bar)
-  end
-
-  it "iterates over output with default delimiter" do
-    result = TTY::Command::Result.new(0, "line1\nline2\nline3", '')
-    expect(result.to_a).to eq(['line1', 'line2', 'line3'])
-  end
-
-  it "iterates over output with global delimiter" do
-    allow(TTY::Command).to receive(:record_separator).and_return("\t")
-    result = TTY::Command::Result.new(0, "line1\tline2\tline3", '')
-    expect(result.each.to_a).to eq(['line1', 'line2', 'line3'])
-  end
-
-  it "iterates over output with argument delimiter" do
-    result = TTY::Command::Result.new(0, "line1\tline2\tline3", '')
-    expect(result.each("\t").to_a).to eq(['line1', 'line2', 'line3'])
-  end
-end

data/spec/unit/ruby_spec.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe TTY::Command, '#ruby' do
-  it "runs ruby with a single string argument" do
-    output = StringIO.new
-    cmd = TTY::Command.new(output: output)
-    out, err = cmd.ruby %q{-e "puts 'Hello World'"}
-    expect(out.chomp).to eq("Hello World")
-    expect(err).to be_empty unless jruby?
-  end
-
-  it "runs ruby with multiple arguments" do
-    output = StringIO.new
-    cmd = TTY::Command.new(output: output)
-    result = double(:success? => true)
-    allow(cmd).to receive(:run).with(TTY::Command::RUBY,
-      'script.rb', 'foo', 'bar', {}).and_return(result)
-    expect(cmd.ruby('script.rb', 'foo', 'bar')).to eq(result)
-  end
-end

data/spec/unit/run_spec.rb

@@ -1,159 +0,0 @@
-RSpec.describe TTY::Command, '#run' do
-  it 'runs command and prints to stdout' do
-    output = StringIO.new
-    command = TTY::Command.new(output: output)
-
-    out, err = command.run(:echo, 'hello')
-
-    expect(out.chomp).to eq("hello")
-    expect(err).to eq("")
-  end
-
-  it 'runs command successfully with logging' do
-    output = StringIO.new
-    uuid= 'xxxx'
-    allow(SecureRandom).to receive(:uuid).and_return(uuid)
-    command = TTY::Command.new(output: output)
-
-    command.run(:echo, 'hello')
-
-    output.rewind
-    lines = output.readlines
-    lines.last.gsub!(/\d+\.\d+/, 'x')
-    expect(lines).to eq([
-      "[\e[32m#{uuid}\e[0m] Running \e[33;1mecho hello\e[0m\n",
-      "[\e[32m#{uuid}\e[0m] \thello\n",
-      "[\e[32m#{uuid}\e[0m] Finished in x seconds with exit status 0 (\e[32;1msuccessful\e[0m)\n"
-    ])
-  end
-
-  it 'runs command successfully with logging without color' do
-    output = StringIO.new
-    uuid= 'xxxx'
-    allow(SecureRandom).to receive(:uuid).and_return(uuid)
-    command = TTY::Command.new(output: output, color: false)
-
-    command.run(:echo, 'hello')
-
-    output.rewind
-    lines = output.readlines
-    lines.last.gsub!(/\d+\.\d+/, 'x')
-    expect(lines).to eq([
-      "[#{uuid}] Running echo hello\n",
-      "[#{uuid}] \thello\n",
-      "[#{uuid}] Finished in x seconds with exit status 0 (successful)\n"
-    ])
-  end
-
-  it 'runs command successfully with logging without uuid set globally' do
-    output = StringIO.new
-    command = TTY::Command.new(output: output, uuid: false)
-
-    command.run(:echo, 'hello')
-    output.rewind
-
-    lines = output.readlines
-    lines.last.gsub!(/\d+\.\d+/, 'x')
-    expect(lines).to eq([
-      "Running \e[33;1mecho hello\e[0m\n",
-      "\thello\n",
-      "Finished in x seconds with exit status 0 (\e[32;1msuccessful\e[0m)\n"
-    ])
-  end
-
-  it 'runs command successfully with logging without uuid set locally' do
-    output = StringIO.new
-    command = TTY::Command.new(output: output)
-
-    command.run(:echo, 'hello', uuid: false)
-    output.rewind
-
-    lines = output.readlines
-    lines.last.gsub!(/\d+\.\d+/, 'x')
-    expect(lines).to eq([
-      "Running \e[33;1mecho hello\e[0m\n",
-      "\thello\n",
-      "Finished in x seconds with exit status 0 (\e[32;1msuccessful\e[0m)\n"
-    ])
-  end
-
-  it "runs command and fails with logging" do
-    non_zero_exit = fixtures_path('non_zero_exit')
-    output = StringIO.new
-    uuid= 'xxxx'
-    allow(SecureRandom).to receive(:uuid).and_return(uuid)
-    command = TTY::Command.new(output: output)
-
-    command.run!("ruby #{non_zero_exit}")
-
-    output.rewind
-    lines = output.readlines
-    lines.last.gsub!(/\d+\.\d+/, 'x')
-    expect(lines).to eq([
-      "[\e[32m#{uuid}\e[0m] Running \e[33;1mruby #{non_zero_exit}\e[0m\n",
-      "[\e[32m#{uuid}\e[0m] \tnooo\n",
-      "[\e[32m#{uuid}\e[0m] Finished in x seconds with exit status 1 (\e[31;1mfailed\e[0m)\n"
-    ])
-  end
-
-  it "raises ExitError on command failure" do
-    non_zero_exit = fixtures_path('non_zero_exit')
-    output = StringIO.new
-    command = TTY::Command.new(output: output)
-
-    expect {
-      command.run("ruby #{non_zero_exit}")
-    }.to raise_error(TTY::Command::ExitError,
-      ["Running `ruby #{non_zero_exit}` failed with",
-       "  exit status: 1",
-       "  stdout: nooo",
-       "  stderr: Nothing written\n"].join("\n")
-    )
-  end
-
-  it "streams output data" do
-    stream = fixtures_path('stream')
-    out_stream = StringIO.new
-    command = TTY::Command.new(output: out_stream)
-    output = ''
-    error = ''
-    command.run("ruby #{stream}") do |out, err|
-     output << out if out
-     error << err if err
-    end
-    expect(output.gsub(/\r\n|\n/,'')).to eq("hello 1hello 2hello 3")
-    expect(error).to eq('')
-  end
-
-  it "preserves ANSI codes" do
-    output = StringIO.new
-    command = TTY::Command.new(output: output, printer: :quiet)
-
-    out, _ = command.run("echo \e[35mhello\e[0m")
-
-    expect(out.chomp).to eq("\e[35mhello\e[0m")
-    expect(output.string.chomp).to eq("\e[35mhello\e[0m")
-  end
-
-  it "logs phased output in one line" do
-    phased_output = fixtures_path('phased_output')
-    uuid= 'xxxx'
-    allow(SecureRandom).to receive(:uuid).and_return(uuid)
-    output = StringIO.new
-    cmd = TTY::Command.new(output: output)
-
-    out, err = cmd.run("ruby #{phased_output}")
-
-    expect(out).to eq('.' * 10)
-    expect(err).to eq('')
-
-    output.rewind
-    lines = output.readlines
-    lines.last.gsub!(/\d+\.\d+/, 'x')
-    expect(lines).to eq([
-      "[\e[32m#{uuid}\e[0m] Running \e[33;1mruby #{phased_output}\e[0m\n",
-      "[\e[32m#{uuid}\e[0m] \t..........\n",
-      "[\e[32m#{uuid}\e[0m] Finished in x seconds with exit status 0 (\e[32;1msuccessful\e[0m)\n"
-    ])
-  end
-end