clin 0.3.0 → 0.4.0

data/spec/clin/line_reader/basic_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Clin::LineReader::Basic do
+  let(:shell) { Clin::Shell.new }
+  describe '#readline' do
+    it 'uses $stdin and $stdout to get input from the user' do
+      expect(shell.out).to receive(:print).with('Where are you from? ')
+      expect(shell.in).to receive(:gets).and_return('France')
+      expect(shell.in).not_to receive(:noecho)
+      reader = Clin::LineReader::Basic.new(shell, 'Where are you from? ', {})
+      expect(reader.readline).to eq('France')
+    end
+
+    it 'disables echo when asked to' do
+      expect(shell.out).to receive(:print).with('Where are you from? ')
+      noecho_stdin = double('noecho_stdin')
+      expect(noecho_stdin).to receive(:gets).and_return('Asgard')
+      expect(shell.in).to receive(:noecho).and_yield(noecho_stdin)
+      reader = Clin::LineReader::Basic.new(shell, 'Where are you from? ', echo: false)
+      expect(reader.readline).to eq('Asgard')
+    end
+  end
+
+  describe '.available?' do
+    it 'returns is always available' do
+      expect(Clin::LineReader::Basic).to be_available
+    end
+  end
+
+  describe '#scan' do
+    it 'call in#gets when echo is true' do
+      reader = Clin::LineReader::Basic.new(shell, 'Where are you from? ', {echo: true})
+      expect(shell.in).to receive(:gets)
+      expect(shell.in).not_to receive(:noecho)
+      reader.send(:scan)
+    end
+
+    it 'call in#noecho(&:gets) when echo is false' do
+      reader = Clin::LineReader::Basic.new(shell, 'Where are you from? ', {echo: false})
+      expect(shell.in).not_to receive(:gets)
+      expect(shell.in).to receive(:noecho)
+      reader.send(:scan)
+    end
+
+    it 'call in#gets if the console does not support noecho' do
+      reader = Clin::LineReader::Basic.new(shell, 'Where are you from? ', {echo: false})
+      expect(shell.in).to receive(:noecho) do
+        fail Errno::EBADF
+      end
+      expect(shell.in).to receive(:gets)
+      reader.send(:scan)
+    end
+  end
+end

data/spec/clin/line_reader/readline_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Clin::LineReader::Readline do
+  let(:shell) { Clin::Shell.new }
+  describe '#readline' do
+    it 'call Readline.readline' do
+      expect(Readline).to receive(:readline).with('> ', true).and_return('val')
+      expect(Readline).not_to receive(:completion_proc=)
+      subject = Clin::LineReader::Readline.new(shell, '> ', {})
+      expect(subject.readline).to eq('val')
+    end
+
+    it 'provides tab completion when given a limited_to option' do
+      countries = ['United States', 'France', 'United Kingdom']
+      expect(Readline).to receive(:readline)
+      expect(Readline).to receive(:completion_proc=) do |proc|
+        expect(proc.call('')).to eq countries
+        expect(proc.call('U')).to eq ['United States', 'United Kingdom']
+        expect(proc.call('United S')).to eq ['United States']
+      end
+
+      subject = Clin::LineReader::Readline.new(shell, 'Where are you from? ',
+                                               autocomplete: countries)
+      subject.readline
+    end
+
+    it 'default back to the basic when echo is false' do
+      expect(shell.out).to receive(:print).with('Where are you from? ')
+      noecho_stdin = double('noecho_stdin')
+      expect(noecho_stdin).to receive(:gets).and_return('Asgard')
+      expect(shell.in).to receive(:noecho).and_yield(noecho_stdin)
+      subject = Clin::LineReader::Readline.new(shell, 'Where are you from? ', echo: false)
+      expect(subject.readline).to eq('Asgard')
+    end
+  end
+
+  describe '.available?' do
+    it 'returns is available by default' do
+      expect(Clin::LineReader::Readline).to be_available
+    end
+
+    it 'returns not available if disable ' do
+      allow(Clin).to receive(:use_readline?).and_return(false)
+      expect(Clin::LineReader::Readline).not_to be_available
+    end
+  end
+
+  describe '#autocomplete?' do
+    it 'return true if defined' do
+      subject = Clin::LineReader::Readline.new(shell, '> ', autocomplete: [''])
+      expect(subject.send(:autocomplete?)).to be_truthy
+    end
+
+    it 'return false if false' do
+      subject = Clin::LineReader::Readline.new(shell, '> ', autocomplete: false)
+      expect(subject.send(:autocomplete?)).to be_falsey
+    end
+
+    it 'return false if not defined' do
+      subject = Clin::LineReader::Readline.new(shell, '> ')
+      expect(subject.send(:autocomplete?)).to be_falsey
+    end
+  end
+end

data/spec/clin/line_reader_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+RSpec.describe Clin::LineReader do
+  let(:shell) { Clin::Shell.new }
+  it 'use readline when use_readline? is true' do
+    expect_any_instance_of(Clin::LineReader::Readline).to receive(:readline)
+    expect_any_instance_of(Clin::LineReader::Basic).not_to receive(:readline)
+    Clin::LineReader.scan(shell, '> ')
+  end
+
+  it 'use basic when use_readline? is false' do
+    allow(Clin).to receive(:use_readline?).and_return(false)
+    expect_any_instance_of(Clin::LineReader::Readline).not_to receive(:readline)
+    expect_any_instance_of(Clin::LineReader::Basic).to receive(:readline)
+    Clin::LineReader.scan(shell, '> ')
+  end
+end

data/spec/clin/option_parser_spec.rb

@@ -0,0 +1,217 @@
+require 'clin'
+
+RSpec.describe Clin::OptionParser do
+  describe '#handle_unknown_option' do
+    let(:name) { :verbose }
+    let(:value) { Faker::Lorem.word }
+
+    context 'when command does not allow unknown options' do
+      let(:command) { double(:command, skip_options?: false) }
+      subject { Clin::OptionParser.new(command, []) }
+
+      before do
+        subject.handle_unknown_option(name, nil)
+      end
+
+      it { expect(subject.errors.size).to be 1 }
+      it { expect(subject.errors.first).to be_a Clin::UnknownOptionError }
+      it { expect(subject.skipped_options).to be_empty }
+    end
+
+    context 'when command allow unknown options and value is given' do
+      let(:command) { double(:command, skip_options?: true) }
+      subject { Clin::OptionParser.new(command, []) }
+
+      before do
+        subject.handle_unknown_option(name, value)
+      end
+
+      it { expect(subject.skipped_options.size).to eq 2 }
+      it { expect(subject.skipped_options).to eq [name, value] }
+    end
+
+    context 'when command allow unknown options and value is nil' do
+      let(:command) { double(:command, skip_options?: true) }
+      subject { Clin::OptionParser.new(command, []) }
+
+      before do
+        allow(subject).to receive(:complete).and_return(value)
+        subject.handle_unknown_option(name, nil)
+      end
+
+      it { expect(subject.skipped_options.size).to eq 2 }
+      it { expect(subject.skipped_options).to eq [name, value] }
+    end
+  end
+
+  describe '#complete' do
+    let(:command) { double(:command) }
+    let(:value) { Faker::Lorem.word }
+    it 'keep the value when the value exists' do
+      parser = Clin::OptionParser.new(command, ['some'])
+      expect(parser.complete(value)).to eq(value)
+      expect(parser.instance_variable_get(:@argv)).to eq(['some'])
+    end
+
+    it 'get next argument value when the value is nil' do
+      parser = Clin::OptionParser.new(command, [value])
+      expect(parser.complete(nil)).to eq(value)
+      expect(parser.instance_variable_get(:@argv)).to eq([])
+    end
+
+    it 'return nil when value is nil and next argument is an option' do
+      parser = Clin::OptionParser.new(command, ['-o'])
+      expect(parser.complete(nil)).to be nil
+      expect(parser.instance_variable_get(:@argv)).to eq(['-o'])
+    end
+  end
+
+  describe '#parse_next' do
+    let(:command) { double(:command) }
+    before do
+      allow(subject).to receive(:parse_short)
+      allow(subject).to receive(:parse_long)
+      subject.parse_next
+    end
+    context 'when option is a long option' do
+      subject { Clin::OptionParser.new(command, ['--opt=val']) }
+      it { expect(subject).to have_received(:parse_long).with('--opt', 'val') }
+      it { expect(subject).not_to have_received(:parse_short) }
+      it { expect(subject.instance_variable_get(:@argv)).to be_empty }
+      it { expect(subject.instance_variable_get(:@arguments)).to be_empty }
+    end
+
+    context 'when option is a short option' do
+      subject { Clin::OptionParser.new(command, ['-oval']) }
+      it { expect(subject).not_to have_received(:parse_long) }
+      it { expect(subject).to have_received(:parse_short).with('-o', 'val') }
+      it { expect(subject.instance_variable_get(:@argv)).to be_empty }
+      it { expect(subject.instance_variable_get(:@arguments)).to be_empty }
+    end
+
+    context 'when option is not an option' do
+      subject { Clin::OptionParser.new(command, ['not opt']) }
+      it { expect(subject).not_to have_received(:parse_short) }
+      it { expect(subject).not_to have_received(:parse_long) }
+      it { expect(subject.instance_variable_get(:@argv)).to be_empty }
+      it { expect(subject.instance_variable_get(:@arguments)).to eq(['not opt']) }
+    end
+  end
+
+  describe '#parse' do
+    let(:command) { double(:command) }
+    subject { Clin::OptionParser.new(command, []) }
+
+    it 'call parse_next until it return false' do
+      expect(subject).to receive(:parse_next).and_return(true, true, false).exactly(3).times
+      subject.parse
+    end
+  end
+
+  describe '#parse_option' do
+    let(:command) { double(:command) }
+    subject { Clin::OptionParser.new(command, []) }
+
+
+    before do
+      allow(subject).to receive(:handle_unknown_option)
+      allow(subject).to receive(:parse_flag_option)
+      subject.parse_option(option, '-o', value, true)
+    end
+
+    context 'when option is nil' do
+      let(:value) { 'val' }
+      let(:option) { nil }
+      it { expect(subject).to have_received(:handle_unknown_option) }
+      it { expect(subject).not_to have_received(:parse_flag_option) }
+    end
+
+    context 'when option is a flag' do
+      let(:value) { 'val' }
+      let(:option) { double(:option, flag?: true) }
+      it { expect(subject).not_to have_received(:handle_unknown_option) }
+      it { expect(subject).to have_received(:parse_flag_option) }
+    end
+
+    context 'when value is nil and argument is required' do
+      let(:value) { nil }
+      let(:option) { double(:option, flag?: false, argument_optional?: false) }
+
+      it { expect(subject).not_to have_received(:handle_unknown_option) }
+      it { expect(subject).not_to have_received(:parse_flag_option) }
+      it { expect(subject.errors.first).to be_a(Clin::MissingOptionArgumentError) }
+    end
+
+    context 'when argument is optional or value is defined' do
+      let(:value) { nil }
+      let(:option) { double(:option, flag?: false, argument_optional?: true, trigger: true) }
+
+      it { expect(subject).not_to have_received(:handle_unknown_option) }
+      it { expect(subject).not_to have_received(:parse_flag_option) }
+      it { expect(subject.errors).to be_empty }
+      it { expect(option).to have_received(:trigger).with(subject, subject.options, true) }
+    end
+  end
+
+  describe '#parse_flag_option' do
+    let(:command) { double(:command) }
+    subject { Clin::OptionParser.new(command, []) }
+    let(:option) { double(:option, flag?: true, trigger: true) }
+
+    before do
+      allow(subject).to receive(:parse_compact_flag_options)
+      subject.parse_flag_option(option, value, short?)
+    end
+
+    context 'when value is nil' do
+      let(:value) { nil }
+      let(:short?) { false }
+      it { expect(option).to have_received(:trigger).with(subject, subject.options, true) }
+    end
+
+    context 'when value exist and name is long' do
+      let(:value) { 'val' }
+      let(:short?) { false }
+      it { expect(option).not_to have_received(:trigger) }
+      it { expect(subject.errors.first).to be_a(Clin::OptionUnexpectedArgumentError) }
+    end
+
+    context 'when value exist and name is short' do
+      let(:value) { 'abc' }
+      let(:short?) { true }
+      it { expect(option).to have_received(:trigger).with(subject, subject.options, true) }
+      it { expect(subject).to have_received(:parse_compact_flag_options) }
+    end
+  end
+
+  describe '#parse_compact_flag_options' do
+    let(:command) { double(:command) }
+    subject { Clin::OptionParser.new(command, []) }
+
+    let (:option1) { double(:option, flag?: true) }
+    let (:option2) { double(:option, flag?: true) }
+    let (:invalid_option) { double(:option, flag?: false) }
+
+    before do
+      allow(subject).to receive(:parse_flag_option)
+      allow(command).to receive(:find_option_by).and_return(*options)
+      subject.parse_compact_flag_options(options_arg)
+    end
+
+    context 'when options are only valid flag options' do
+      let(:options_arg) { 'ab' }
+      let(:options) { [option1, option2] }
+
+      it { expect(subject).to have_received(:parse_flag_option).twice }
+      it { expect(subject.errors).to be_empty }
+    end
+
+    context 'when 1 option is not a flag' do
+      let(:options_arg) { 'abc' }
+      let(:options) { [option1, invalid_option, option2] }
+
+      it { expect(subject).to have_received(:parse_flag_option).once }
+      it { expect(subject.errors.first).to be_a Clin::OptionError }
+    end
+  end
+end

data/spec/clin/option_spec.rb

@@ -19,7 +19,7 @@ RSpec.describe Clin::Option do
     end
   end
 
-  describe '#extract' do
+  describe '#trigger' do
     let(:out) { Hash.new }
     let(:opts) { double(:opts) }
     let(:value) { 'some' }
@@ -32,20 +32,18 @@ RSpec.describe Clin::Option do
     context 'when initializing with name' do
       subject { Clin::Option.new(:my_option, 'This is my option!') }
       before do
-        subject.register(opts, out)
+        subject.trigger(opts, out, value)
       end
-      it { expect(opts).to have_received(:on).once }
       it { expect(out[:my_option]).to eq(value) }
     end
 
     context 'when initializing with block' do
-      let(:block) { proc { |_opts, out, value| out[:some] = value } }
+      let(:block) { proc { |_opts, out, value| out[:some] = "new val #{value}" } }
       subject { Clin::Option.new(:my_option, 'This is my option!', &block) }
       before do
-        subject.register(opts, out)
+        subject.trigger(opts, out, value)
       end
-      it { expect(opts).to have_received(:on).once }
-      it { expect(out[:some]).to eq(value) }
+      it { expect(out[:some]).to eq("new val #{value}") }
 
     end
   end

data/spec/clin/shell_interaction/choose_spec.rb

@@ -51,4 +51,34 @@ RSpec.describe Clin::ShellInteraction::Choose do
       expect(subject.run('Where are you from?', countries)).to eq('france')
     end
   end
+
+  describe '#choice_help' do
+    def same?(value, actual)
+      expect(value.to_s.split("\n").map(&:rstrip)).to eq(actual.to_s.split("\n").map(&:rstrip))
+    end
+
+    let(:choices) { {yes: 'You want it!', no: "No you don't!", yeeahno: "I can't make up my mind!"} }
+    it 'get help without initials' do
+      help = subject.choice_help(choices).to_s
+      expected = <<help
+Choose from:
+  yes      You want it!
+  no       No you don't!
+  yeeahno  I can't make up my mind!
+help
+      same?(help, expected)
+    end
+
+    it 'get help with initials' do
+      help = subject.choice_help(choices, allow_initials: true).to_s
+      expected = <<help
+Choose from:
+  y - yes      You want it!
+  n - no       No you don't!
+      yeeahno  I can't make up my mind!
+help
+      same?(help, expected)
+      # expect(help).to eq(expected)
+    end
+  end
 end

data/spec/clin/shell_interaction/file_interaction_spec.rb

@@ -0,0 +1,18 @@
+require 'clin'
+
+RSpec.describe Clin::ShellInteraction::FileConflict do
+  let(:shell) { Clin::Shell.new }
+  subject { Clin::ShellInteraction::FileConflict.new(shell) }
+
+  describe 'show_diff' do
+    it 'open a tmp file' do
+      file = double(:file, path: 'tmp/filename.txt')
+      expect(file).to receive(:write).with('new_content')
+      expect(file).to receive(:rewind)
+      expect(Tempfile).to receive(:open).with('filename.txt').and_yield(file)
+      expect_any_instance_of(Kernel)
+        .to receive(:system).with('diff -u "path/filename.txt" "tmp/filename.txt"')
+      subject.send(:show_diff, 'path/filename.txt', 'new_content')
+    end
+  end
+end

data/spec/clin/shell_interaction/select_spec.rb

@@ -0,0 +1,96 @@
+require 'clin'
+
+RSpec.describe Clin::ShellInteraction::Select do
+  let(:shell) { Clin::Shell.new }
+  subject { Clin::ShellInteraction::Select.new(shell) }
+
+  def expects_scan(*outputs)
+    expect(shell).to receive(:scan).with('>', any_args)
+                       .and_return(*outputs).exactly(outputs.size).times
+  end
+
+  describe '#run' do
+    suppress_puts
+    let(:choices) { %w(usa france germany italy) }
+
+    it 'ask for a choice and return the user reply' do
+      expects_scan('france')
+      expect(subject.run('Where are you from?', choices)).to eq('france')
+    end
+
+    it 'ask for a choice and return the default' do
+      expects_scan('')
+      expect(subject).to receive(:choice_help).once
+      expect(subject.run('Where are you from?', choices, default: 'germany')).to eq('germany')
+    end
+
+    it 'get the value using index' do
+      expects_scan('4')
+      expect(subject).to receive(:choice_help).once
+      expect(subject.run('Where are you from?', choices)).to eq('italy')
+    end
+
+    it 'keep asking until the answer is valid' do
+      expects_scan('spain', 'russia', 'france')
+      expect(subject).to receive(:choice_help).exactly(3).times
+      expect(subject.run('Where are you from?', choices)).to eq('france')
+    end
+
+    it 'keep asking until the answer is valid' do
+      expects_scan('0', '10', '2')
+      expect(subject).to receive(:choice_help).exactly(3).times
+      expect(subject.run('Where are you from?', choices)).to eq('france')
+    end
+  end
+
+  describe '#get_choice' do
+    let(:choices) { ['Choice A', 'Choice B', 'Choice C', 'Choice D'] }
+
+    it 'get choice with its value' do
+      expect(subject.get_choice(choices, 'Choice B', 1)).to eq('Choice B')
+    end
+
+    it 'get choice with its index' do
+      expect(subject.get_choice(choices, '3', 1)).to eq('Choice C')
+    end
+
+    it 'return nil when value is less' do
+      expect(subject.get_choice(choices, '0', 1)).to be nil
+    end
+    it 'return nil when value is less' do
+      expect(subject.get_choice(choices, '5', 1)).to be nil
+    end
+  end
+
+  describe '#choice_help' do
+    def same?(value, actual)
+      expect(value.to_s.split("\n").map(&:rstrip)).to eq(actual.to_s.split("\n").map(&:rstrip))
+    end
+
+    let(:choices) { ['Choice A', 'Choice B', 'Choice C'] }
+    let(:choices_desc) { {'Choice A' => 'This is choice A',
+                          'Choice Long' => 'This is choice B',
+                          'Choice C' => 'This is choice C'} }
+    it 'get help without description' do
+      help = subject.choice_help(choices, 1).to_s
+      expected = <<help
+1. Choice A
+2. Choice B
+3. Choice C
+help
+      # same?(help, expected)
+      expect(help).to eq(expected)
+    end
+
+    it 'get help with description' do
+      help = subject.choice_help(choices_desc, 0).to_s
+      expected = <<help
+0. Choice A,    This is choice A
+1. Choice Long, This is choice B
+2. Choice C,    This is choice C
+help
+      # same?(help, expected)
+      expect(help).to eq(expected)
+    end
+  end
+end

data/spec/clin/shell_spec.rb

@@ -5,6 +5,22 @@ RSpec.describe Clin::Shell do
     expect(subject).to receive(:scan).with(message, any_args).and_return(*outputs).exactly(outputs.size).times
   end
 
+  describe '#say' do
+    it 'call text#line' do
+      expect(subject.out).to receive(:puts).with('  Lorem Ipsum')
+      subject.say('Lorem Ipsum', indent: 2)
+    end
+  end
+
+  describe '#indent' do
+    it 'call text#line' do
+      expect(subject.out).to receive(:puts).with('  **Lorem Ipsum')
+      subject.indent 2 do
+        subject.say('Lorem Ipsum', indent: '**')
+      end
+    end
+  end
+
   describe '#ask' do
     it 'ask for a question and return user reply' do
       expects_scan('What is your name?', 'Smith')
@@ -17,6 +33,14 @@ RSpec.describe Clin::Shell do
     end
   end
 
+  describe '#password' do
+    it 'call ask with echo and add_to_history false' do
+      expect(subject).to receive(:ask)
+                           .with('Password?', default: 'lorem', echo: false, add_to_history: false)
+      subject.password('Password?', default: 'lorem')
+    end
+  end
+
   describe '#choose' do
     let(:countries) { %w(usa france germany italy) }
 
@@ -36,6 +60,16 @@ RSpec.describe Clin::Shell do
     end
   end
 
+  describe '#select' do
+    it 'call ask with echo and add_to_history false' do
+      select = double(:select_interaction)
+      choices = %w(France Germany Italy Spain)
+      expect(select).to receive(:run).with('Where are you from?', choices, default: 'France')
+      expect(Clin::ShellInteraction::Select).to receive(:new).and_return(select)
+      subject.select('Where are you from?', choices, default: 'France')
+    end
+  end
+
   describe '#yes_or_no' do
     it 'asks the user and returns true if the user replies y' do
       expects_scan('Is earth round? [yn]', 'y')
@@ -144,4 +178,12 @@ RSpec.describe Clin::Shell do
       expect(subject.keep?('some.txt')).to be false
     end
   end
+
+  describe '#scan' do
+    it 'call LineReader.scan' do
+      options = {opt1: 'val1', opt2: 'val2'}
+      expect(Clin::LineReader).to receive(:scan).with(subject, 'Where are you from? ', options)
+      subject.send(:scan, 'Where are you from?', options)
+    end
+  end
 end

data/spec/clin/text/table_cell_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+RSpec.describe Clin::Text::TableCell do
+  def table_double(options)
+    double(:table, options.reverse_merge(column_length: {}, update_column_length: true))
+  end
+
+  describe '#length' do
+    let(:index) { 1 }
+    let(:table) { table_double(column_length: [1, 2, 3]) }
+    subject { Clin::Text::TableCell.new(table, index, 'val') }
+
+    it 'Get the length of the corresponding column' do
+      expect(subject.length).to eq(2)
+    end
+  end
+
+  describe '#align' do
+    let(:index) { 1 }
+    let(:table) { table_double(align: align) }
+    subject { Clin::Text::TableCell.new(table, 1, 'val') }
+
+    context 'when align was set using a symbol' do
+      let(:align) { :center }
+
+      it 'return the global align setting' do
+        expect(subject.align).to eq(align)
+      end
+    end
+
+    context 'when align was set column specific' do
+      let(:align) { [:center, :right, :center] }
+
+      it 'return the column specific setting' do
+        expect(subject.align).to eq(:right)
+      end
+    end
+
+    context 'when align is in wrong format' do
+      let(:align) { {left: true} }
+
+      it 'return the column specific setting' do
+        expect { subject.align }.to raise_error(Clin::Error)
+      end
+    end
+  end
+
+  describe '#to_s' do
+    let(:table) { table_double(column_length: {}) }
+    subject { Clin::Text::TableCell.new(table, 1, 'value') }
+
+    before do
+      allow(subject).to receive(:length).and_return(9)
+      allow(subject).to receive(:align).and_return(align)
+    end
+
+    context 'when align is left' do
+      let(:align) { :left }
+      it { expect(subject.to_s).to eq('value    ') }
+    end
+
+    context 'when align is right' do
+      let(:align) { :right }
+      it { expect(subject.to_s).to eq('    value') }
+    end
+
+    context 'when align is center' do
+      let(:align) { :center }
+      it { expect(subject.to_s).to eq('  value  ') }
+    end
+  end
+end