tty 0.2.1 → 0.3.0

data/spec/tty/shell/question/validation/valid_value_spec.rb

@@ -1,28 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Shell::Question::Validation, '#valid_value?' do
-  let(:validation) { /^[^\.]+\.[^\.]+/ }
-  let(:instance) { described_class.new validation }
-
-  subject { instance.valid_value?(value) }
-
-  context '' do
-    let(:value) { nil }
-
-    it { is_expected.to eq(false) }
-  end
-
-  context 'when the value matches validation' do
-    let(:value) { 'piotr.murach' }
-
-    it { is_expected.to eq(true) }
-  end
-
-  context 'when the value is not matching validation' do
-    let(:value)  { 'piotrmurach' }
-
-    it { expect { subject }.to raise_error(TTY::InvalidArgument) }
-  end
-end

data/spec/tty/shell/reader/getc_spec.rb

@@ -1,42 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Shell::Reader, '#getc' do
-  let(:instance) { described_class.new(shell) }
-
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:shell) { TTY::Shell.new(input, output) }
-
-  subject(:reader) { instance.getc mask }
-
-  context 'with mask' do
-    let(:mask) { '*'}
-
-    it 'masks characters' do
-      input << "password\n"
-      input.rewind
-      expect(reader).to eql "password"
-      expect(output.string).to eql("********")
-    end
-  end
-
-  context "without mask" do
-    let(:mask) { }
-
-    it 'masks characters' do
-      input << "password\n"
-      input.rewind
-      expect(reader).to eql "password"
-      expect(output.string).to eql("password")
-    end
-
-    it 'deletes characters when backspace pressed' do
-      input << "\b\b"
-      input.rewind
-      expect(reader).to eql ''
-      expect(output.string).to eql('')
-    end
-  end
-end

data/spec/tty/shell/response/read_bool_spec.rb

@@ -1,40 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Shell::Question, '#read_bool' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:shell) { TTY::Shell.new(input, output) }
-
-  it 'fails to read boolean' do
-    input << 'invalid'
-    input.rewind
-    q = shell.ask("Do you read books?")
-    expect { q.read_bool }.to raise_error(Necromancer::ConversionTypeError)
-  end
-
-  it 'reads negative boolean' do
-    input << 'No'
-    input.rewind
-    q = shell.ask("Do you read books?")
-    answer = q.read_bool
-    expect(answer).to eql false
-  end
-
-  it 'reads positive boolean' do
-    input << 'Yes'
-    input.rewind
-    q = shell.ask("Do you read books?")
-    answer = q.read_bool
-    expect(answer).to eql true
-  end
-
-  it 'reads single positive boolean' do
-    input << 'y'
-    input.rewind
-    q = shell.ask("Do you read books?")
-    answer = q.read_bool
-    expect(answer).to eql true
-  end
-end

data/spec/tty/shell/response/read_char_spec.rb

@@ -1,16 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Shell::Question, '#read_char' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:shell) { TTY::Shell.new(input, output) }
-
-  it 'reads single character' do
-    input << "abcde"
-    input.rewind
-    q = shell.ask("What is your favourite letter?")
-    expect(q.read_char).to eql "a"
-  end
-end

data/spec/tty/shell/response/read_date_spec.rb

@@ -1,20 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Shell::Question, '#read_date' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:shell) { TTY::Shell.new(input, output) }
-
-  it 'reads date' do
-    input << "20th April 1887"
-    input.rewind
-    q = shell.ask("When were your born?")
-    answer = q.read_date
-    expect(answer).to be_kind_of Date
-    expect(answer.day).to eql 20
-    expect(answer.month).to eql 4
-    expect(answer.year).to eql 1887
-  end
-end

data/spec/tty/shell/response/read_email_spec.rb

@@ -1,42 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Shell::Question, '#read_email' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:shell) { TTY::Shell.new(input, output) }
-
-  context 'with valid email' do
-    it 'reads empty' do
-      input << ""
-      input.rewind
-      q = shell.ask("What is your email?")
-      expect { q.read_email }.to raise_error(TTY::InvalidArgument)
-    end
-
-    it 'reads valid email' do
-      input << "piotr@example.com"
-      input.rewind
-      q = shell.ask("What is your email?")
-      expect(q.read_email).to eql "piotr@example.com"
-    end
-  end
-
-  context 'with invalid email' do
-    it 'fails to read invalid email' do
-      input << "this will@neverwork"
-      input.rewind
-      q = shell.ask("What is your email?")
-      expect { q.read_email }.to raise_error(TTY::InvalidArgument)
-    end
-
-    it 'reads invalid and asks again' do
-      input << "this will@neverwork\nthis.will@example.com"
-      input.rewind
-      q = shell.ask("What is your email?").on_error(:retry)
-      expect(q.read_email).to eql "this.will@example.com"
-      expect(output.string).to eql "What is your email?\nWhat is your email?\n"
-    end
-  end
-end

data/spec/tty/shell/response/read_multiple_spec.rb

@@ -1,23 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Shell::Question, '#read_multiple' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:shell) { TTY::Shell.new(input, output) }
-
-  it 'reads multiple lines' do
-    input << "First line\nSecond line\nThird line"
-    input.rewind
-    q = shell.ask("Provide description?")
-    expect(q.read_multiple).to eq("First line\nSecond line\nThird line")
-  end
-
-  it 'skips empty lines' do
-    input << "First line\n\nSecond line"
-    input.rewind
-    q = shell.ask("Provide description?")
-    expect(q.read_multiple).to eq("First line\nSecond line")
-  end
-end

data/spec/tty/shell/response/read_number_spec.rb

@@ -1,28 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Shell::Question, '#read_numbers' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:shell) { TTY::Shell.new(input, output) }
-
-  it 'reads integer' do
-    input << 35
-    input.rewind
-    q = shell.ask("What temperature?")
-    answer = q.read_int
-    expect(answer).to be_kind_of Integer
-    expect(answer).to eql 35
-  end
-
-  it 'reads float' do
-    number = 6.666
-    input << number
-    input.rewind
-    q = shell.ask("How tall are you?")
-    answer = q.read_float
-    expect(answer).to be_kind_of Float
-    expect(answer).to eql number
-  end
-end

data/spec/tty/shell/response/read_range_spec.rb

@@ -1,31 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Shell::Question, '#read_range' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:shell)  { TTY::Shell.new(input, output) }
-
-  subject {
-    input << value
-    input.rewind
-    shell.ask("Which age group?").read_range
-  }
-
-  context 'with valid range' do
-    let(:value) { "20-30" }
-
-    it { expect(subject).to be_kind_of Range }
-
-    it { expect(subject).to eql (20..30) }
-  end
-
-  context 'with invalid range' do
-    let(:value) { "abcd" }
-
-    it "fails to convert to range" do
-      expect { subject }.to raise_error(Necromancer::ConversionTypeError)
-    end
-  end
-end # read_range

data/spec/tty/shell/response/read_spec.rb

@@ -1,68 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Shell::Question, '#read_password' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:shell) { TTY::Shell.new(input, output) }
-
-  context 'with no mask' do
-    it 'asks with echo on' do
-      input << "password"
-      input.rewind
-      q = shell.ask("What is your password: ").echo(true)
-      expect(q.read).to eql("password")
-      expect(output.string).to eql('What is your password: ')
-      expect(q.mask?).to eq(false)
-    end
-
-    it 'asks with echo off' do
-      input << "password"
-      input.rewind
-      q = shell.ask("What is your password: ").echo(false)
-      expect(q.read).to eql("password")
-      expect(output.string).to eql('What is your password: ')
-      expect(q.mask?).to eq(false)
-    end
-  end
-
-  context 'with mask' do
-    it 'masks output with character' do
-      input << "password\n"
-      input.rewind
-      q = shell.ask("What is your password: ").mask('*')
-      expect(q.read).to eql("password")
-      expect(output.string).to eql('What is your password: ********')
-      expect(q.mask?).to eq(true)
-    end
-
-    it 'ignores mask if echo is off' do
-      input << "password"
-      input.rewind
-      q = shell.ask("What is your password: ").echo(false).mask('*')
-      expect(q.read).to eql("password")
-      expect(output.string).to eql('What is your password: ')
-      expect(q.mask?).to eq(true)
-    end
-  end
-
-  context 'with mask and echo as options' do
-    it 'asks with options' do
-      input << "password"
-      input.rewind
-      q = shell.ask("What is your password: ", :echo => false, :mask => '*')
-      expect(q.read_password).to eq("password")
-    end
-
-    it 'asks with block' do
-      input << "password"
-      input.rewind
-      q = shell.ask "What is your password: " do
-        echo  false
-        mask '*'
-      end
-      expect(q.read_password).to eq("password")
-    end
-  end
-end

data/spec/tty/shell/response/read_string_spec.rb

@@ -1,19 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Shell::Question, '#initialize' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:shell)  { TTY::Shell.new(input, output) }
-
-  it 'reads string' do
-    name = "Piotr"
-    input << name
-    input.rewind
-    q = shell.ask("What is your name?")
-    answer = q.read_string
-    expect(answer).to be_kind_of String
-    expect(answer).to eql name
-  end
-end

data/spec/tty/shell/say_spec.rb

@@ -1,67 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-describe TTY::Shell, '#say' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:color)  { Pastel.new(enabled: true) }
-
-  subject(:shell) { TTY::Shell.new(input, output) }
-
-  before { allow(Pastel).to receive(:new).and_return(color) }
-
-  after { output.rewind }
-
-  it 'prints an empty message' do
-    shell.say ""
-    expect(output.string).to eql ""
-  end
-
-  context 'with new line' do
-    it 'prints a message with newline' do
-      shell.say "Hell yeah!\n"
-      expect(output.string).to eql "Hell yeah!\n"
-    end
-
-    it 'prints a message with implicit newline' do
-      shell.say "Hell yeah!\n"
-      expect(output.string).to eql "Hell yeah!\n"
-    end
-
-    it 'prints a message with newline within text' do
-      shell.say "Hell\n yeah!"
-      expect(output.string).to eql "Hell\n yeah!\n"
-    end
-
-    it 'prints a message with newline within text and blank space' do
-      shell.say "Hell\n yeah! "
-      expect(output.string).to eql "Hell\n yeah! "
-    end
-
-    it 'prints a message without newline' do
-      shell.say "Hell yeah!", :newline => false
-      expect(output.string).to eql "Hell yeah!"
-    end
-  end
-
-  context 'with tab or space' do
-    it 'prints ' do
-      shell.say "Hell yeah!\t"
-      expect(output.string).to eql "Hell yeah!\t"
-    end
-  end
-
-  context 'with color' do
-    it 'prints message with ansi color' do
-      shell.say "Hell yeah!", :color => :green
-      expect(output.string).to eql "\e[32mHell yeah!\e[0m\n"
-    end
-
-    it 'prints message with ansi color without newline' do
-      shell.say "Hell yeah! ", :color => :green
-      expect(output.string).to eql "\e[32mHell yeah! \e[0m"
-    end
-  end
-
-end # say

data/spec/tty/shell/statement/initialize_spec.rb

@@ -1,15 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-RSpec.describe TTY::Shell::Statement, '#new' do
-  let(:input)  { StringIO.new }
-  let(:output) { StringIO.new }
-  let(:shell) { TTY::Shell.new(input, output) }
-
-  subject(:statement) { described_class.new }
-
-  it { expect(statement.newline).to eq(true) }
-
-  it { expect(statement.color).to eq(false) }
-end