tty-prompt 0.1.0

data/spec/unit/question/argument_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Prompt::Question, '#argument' do
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:prompt)  { TTY::Prompt.new(input, output) }
+
+  it 'requires value to be present with helper' do
+    input << ''
+    input.rewind
+    q = prompt.ask("What is your name?").argument(:required)
+    expect { q.read }.to raise_error(ArgumentError)
+  end
+
+  it 'requires value to be present with option' do
+    input << ''
+    input.rewind
+    q = prompt.ask("What is your name?", required: true)
+    expect { q.read }.to raise_error(ArgumentError)
+  end
+
+  it "doesn't require value to be present" do
+    input << ''
+    input.rewind
+    q = prompt.ask("What is your name?").argument(:optional)
+    expect(q.read).to be_nil
+  end
+end

data/spec/unit/question/character_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Prompt::Question, '#character' do
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:prompt) { TTY::Prompt.new(input, output) }
+
+  it 'switches to character input' do
+    input << "abcd"
+    input.rewind
+    q = prompt.ask("Which one do you prefer a, b, c or d?").char(true)
+    expect(q.character)
+    expect(q.read_string).to eq("abcd")
+  end
+
+  it 'acts as reader without arguments' do
+    input << "abcd"
+    input.rewind
+    q = prompt.ask("Which one do you prefer a, b, c or d?")
+    expect(q.char).to eq(false)
+  end
+end

data/spec/unit/question/default_spec.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Prompt::Question, '#default' do
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:prompt) { TTY::Prompt.new(input, output) }
+
+  it 'uses default value' do
+    name = 'Anonymous'
+    q = prompt.ask("What is your name?").default(name)
+    answer = q.read
+    expect(answer).to eq(name)
+  end
+
+  it 'uses default value in block' do
+    name = 'Anonymous'
+    q = prompt.ask "What is your name?" do
+      default name
+    end
+    answer = q.read
+    expect(answer).to eq(name)
+  end
+end

data/spec/unit/question/in_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Prompt::Question, '#in' do
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:prompt) { TTY::Prompt.new(input, output) }
+
+  it 'reads number within range' do
+    input << 8
+    input.rewind
+    q = prompt.ask("How do you like it on scale 1-10").in('1-10')
+    expect(q.read_int).to eql 8
+  end
+
+  it "reads number outside of range" do
+    input << 12
+    input.rewind
+    q = prompt.ask("How do you like it on scale 1-10").in('1-10')
+    expect { q.read_int }.to raise_error(ArgumentError)
+  end
+end

data/spec/unit/question/initialize_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Prompt::Question, '#initialize' do
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:prompt) { TTY::Prompt.new(input, output) }
+  let(:message) { 'Do you like me?' }
+
+  subject(:question) { described_class.new prompt }
+
+  it { expect(question.required?).to eq(false) }
+
+  it { expect(question.echo).to eq(true) }
+
+  it { expect(question.mask).to eq(false) }
+
+  it { expect(question.character).to eq(false) }
+
+  it { expect(question.modifier).to be_kind_of(TTY::Prompt::Question::Modifier) }
+
+  it { expect(question.validation).to be_kind_of(TTY::Prompt::Question::Validation) }
+end

data/spec/unit/question/modifier/apply_to_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Prompt::Question::Modifier, '#apply_to' do
+  let(:instance) { described_class.new modifiers }
+  let(:string)   { "Text to be modified"}
+
+  it "doesn't apply modifiers" do
+    modifier = described_class.new([])
+    expect(modifier.apply_to(string)).to eq(string)
+  end
+
+  it 'applies letter case modifications' do
+    modifiers = [:down, :capitalize]
+    allow(described_class).to receive(:letter_case)
+    modifier = described_class.new(modifiers)
+    modifier.apply_to(string)
+    expect(described_class).to have_received(:letter_case).
+      with(modifiers, string)
+  end
+
+  it 'applies whitespace modifications' do
+    modifiers = [:up, :capitalize]
+    allow(described_class).to receive(:whitespace)
+    modifier = described_class.new(modifiers)
+    modifier.apply_to(string)
+    expect(described_class).to have_received(:whitespace).
+      with(modifiers, string)
+  end
+end

data/spec/unit/question/modifier/letter_case_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Prompt::Question::Modifier, '#letter_case' do
+  let(:string) { 'text to modify' }
+
+  it "changes to uppercase" do
+    modified = described_class.letter_case(:up, string)
+    expect(modified).to eq('TEXT TO MODIFY')
+  end
+
+  it "changes to lower case" do
+    modified = described_class.letter_case(:down, string)
+    expect(modified).to eq('text to modify')
+  end
+
+  it "capitalizes text" do
+    modified = described_class.letter_case(:capitalize, string)
+    expect(modified).to eq('Text to modify')
+  end
+end

data/spec/unit/question/modifier/whitespace_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Prompt::Question::Modifier, '#whitespace' do
+  let(:string) { "  text\t \n  to\t   modify\r\n" }
+
+  subject { described_class.whitespace modifier, string}
+
+  context 'when stripping whitespace' do
+    let(:modifier) { :trim }
+
+    it { is_expected.to eq("text\t \n  to\t   modify") }
+  end
+
+  context 'when chomping whitespace' do
+    let(:modifier) { :chomp }
+
+    it { is_expected.to eq("  text\t \n  to\t   modify") }
+  end
+
+  context 'when capitalize' do
+    let(:modifier) { :collapse }
+
+    it { is_expected.to eq(" text to modify ") }
+  end
+
+  context 'when removing whitespace' do
+    let(:modifier) { :remove }
+
+    it { is_expected.to eq("texttomodify") }
+  end
+end

data/spec/unit/question/modify_spec.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Prompt::Question, '#modify' do
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:prompt)  { TTY::Prompt.new(input, output) }
+
+  it 'preserves answer for unkown modification' do
+    input << 'piotr'
+    input.rewind
+    q = prompt.ask("What is your name?").modify(:none)
+    expect(q.read_string).to eql 'piotr'
+  end
+
+  it 'converts to upper case' do
+    input << 'piotr'
+    input.rewind
+    q = prompt.ask("What is your name?").modify(:upcase)
+    expect(q.read_string).to eql 'PIOTR'
+  end
+
+  it 'trims whitespace' do
+    input << " Some   white\t   space\t \there!   \n"
+    input.rewind
+    q = prompt.ask("Enter some text: ").modify(:trim)
+    expect(q.read_string).to eql "Some   white\t   space\t \there!"
+  end
+
+  it 'collapses whitespace' do
+    input << " Some   white\t   space\t \there!   \n"
+    input.rewind
+    q = prompt.ask("Enter some text: ").modify(:collapse)
+    expect(q.read_string).to eql "Some white space here!"
+  end
+
+  it 'strips and collapses whitespace' do
+    input << " Some   white\t   space\t \there!   \n"
+    input.rewind
+    q = prompt.ask("Enter some text: ").modify(:strip, :collapse)
+    expect(q.read_string).to eql "Some white space here!"
+  end
+end

data/spec/unit/question/valid_spec.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Prompt::Question, '#valid' do
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:prompt) { TTY::Prompt.new(input, output) }
+
+  let(:cards) { %w[ club diamond spade heart ] }
+
+  it 'reads valid optios with helper' do
+    input << 'club'
+    input.rewind
+    q = prompt.ask("What is your card suit sir?").valid(cards)
+    expect(q.read_choice).to eq('club')
+  end
+
+  it 'reads valid options with option hash' do
+    input << 'club'
+    input.rewind
+    q = prompt.ask("What is your card suit sir?", valid: cards)
+    expect(q.read_choice).to eq('club')
+  end
+
+  it 'reads invalid option' do
+    input << 'clover'
+    input.rewind
+    q = prompt.ask("What is your card suit sir?").valid(cards)
+    expect { q.read_choice }.to raise_error(TTY::Prompt::InvalidArgument)
+  end
+
+  it 'needs argument' do
+    input << ''
+    input.rewind
+    q = prompt.ask("What is your card suit sir?").valid(cards)
+    expect { q.read_choice }.to raise_error(TTY::Prompt::ArgumentRequired)
+  end
+
+  it 'reads with default' do
+    input << ''
+    input.rewind
+    q = prompt.ask("What is your card suit sir?").valid(cards).default('club')
+    expect(q.read_choice).to eq('club')
+  end
+end

data/spec/unit/question/validate_spec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Prompt::Question, '#validate' do
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:prompt)  { TTY::Prompt.new(input, output) }
+
+  it 'fails to validate input' do
+    input << 'piotrmurach'
+    input.rewind
+    q = prompt.ask("What is your username?").validate(/^[^\.]+\.[^\.]+/)
+    expect { q.read_string }.to raise_error(ArgumentError)
+  end
+
+  it 'validates input with regex' do
+    input << 'piotr.murach'
+    input.rewind
+    q = prompt.ask("What is your username?").validate(/^[^\.]+\.[^\.]+/)
+    expect(q.read_string).to eq('piotr.murach')
+  end
+
+  it 'validates input in block' do
+    input << 'piotr.murach'
+    input.rewind
+    q = prompt.ask("What is your username?").validate { |arg| arg =~ /^[^\.]+\.[^\.]+/ }
+    expect(q.read_string).to eq('piotr.murach')
+  end
+end

data/spec/unit/question/validation/coerce_spec.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Prompt::Question::Validation, '#coerce' do
+  let(:instance) { described_class.new }
+
+  it "coerces into proc" do
+    validation = lambda { "^[^\.]+\.[^\.]+" }
+    expect(instance.coerce(validation)).to be_kind_of(Proc)
+  end
+
+  it "cources into regex" do
+    validation = "^[^\.]+\.[^\.]+"
+    expect(instance.coerce(validation)).to be_kind_of(Regexp)
+  end
+
+  it "fails to coerce validation" do
+    validation = Object.new
+    expect {
+      instance.coerce(validation)
+    }.to raise_error(TTY::Prompt::ValidationCoercion)
+  end
+end

data/spec/unit/question/validation/valid_value_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Prompt::Question::Validation, '#valid_value?' do
+  let(:validation) { /^[^\.]+\.[^\.]+/ }
+  let(:instance) { described_class.new validation }
+
+  it "validates nil input" do
+    expect(instance.valid_value?(nil)).to eq(false)
+  end
+
+  it "validates successfully when the value matches pattern" do
+    expect(instance.valid_value?('piotr.murach')).to eq(true)
+  end
+
+  it "fails validation when not maching pattern" do
+    expect {
+      instance.valid_value?('piotrmurach')
+    }.to raise_error(TTY::Prompt::InvalidArgument)
+  end
+end

data/spec/unit/reader/getc_spec.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Prompt::Reader, '#getc' do
+  let(:instance) { described_class.new(prompt) }
+
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:prompt) { TTY::Prompt.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/unit/response/read_bool_spec.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+RSpec.describe TTY::Prompt::Question, '#read_bool' do
+  let(:input)  { StringIO.new }
+  let(:output) { StringIO.new }
+  let(:prompt) { TTY::Prompt.new(input, output) }
+
+  it 'fails to read boolean' do
+    input << 'invalid'
+    input.rewind
+    q = prompt.ask("Do you read books?")
+    expect { q.read_bool }.to raise_error(Necromancer::ConversionTypeError)
+  end
+
+  it "handles default values" do
+    input << "\n"
+    input.rewind
+    q = prompt.ask("Do you read books?").default(true)
+    expect(q.read_bool).to eql(true)
+  end
+
+  it 'reads negative boolean' do
+    input << 'No'
+    input.rewind
+    q = prompt.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 = prompt.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 = prompt.ask("Do you read books?")
+    answer = q.read_bool
+    expect(answer).to eql true
+  end
+end