highline_wrapper 0.1.0 → 1.0.0

data/lib/highline_wrapper/checkbox_question.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'question'
+
+class HighlineWrapper
+  class CheckboxQuestion < Question
+    class << self
+      def ask(prompt, choices, options)
+        indices = ask_highline(format_options(prompt, choices))
+        puts
+
+        return format_multiple_selections(choices, indices, options[:with_indexes]) unless indices.empty?
+        return recurse(prompt, choices, options) if options[:required]
+        return options[:defaults] if options[:defaults].empty?
+
+        format_multiple_selections(choices, options[:defaults].map { |d| choices.index(d) }, options[:with_indexes])
+      end
+
+      private def ask_highline(prompt)
+        indices = []
+        super(prompt).to_s.split(',').each { |i| indices << i.strip.to_i - 1 }
+        indices
+      end
+
+      private def format_multiple_selections(choices, indices, with_indexes)
+        selected = []
+        indices.each { |index| selected << format_selection(choices, index, with_indexes) }
+        selected
+      end
+    end
+  end
+end

data/lib/highline_wrapper/multiple_choice_question.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'question'
+
+class HighlineWrapper
+  class MultipleChoiceQuestion < Question
+    class << self
+      def ask(prompt, choices, options)
+        index = ask_highline(format_options(prompt, choices)).to_i - 1
+        puts
+
+        return format_selection(choices, index, options[:with_index]) unless index == -1
+        return recurse(prompt, choices, options) if options[:required]
+        return nil if options[:default].nil?
+
+        format_selection(choices, choices.index(options[:default]), options[:with_index])
+      end
+    end
+  end
+end

data/lib/highline_wrapper/open_ended_question.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'question'
+
+class HighlineWrapper
+  class OpenEndedQuestion < Question
+    class << self
+      def ask(prompt, options)
+        answer = ask_highline(prompt, secret: options[:secret]).to_s
+        puts unless answer.empty? && options[:secret]
+
+        return answer unless answer.empty?
+        return recurse(prompt, nil, options) if options[:required]
+
+        options[:default]
+      end
+    end
+  end
+end

data/lib/highline_wrapper/question.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class HighlineWrapper
+  class Question
+    class << self
+      def ask_highline(prompt, secret: false)
+        highline.ask(prompt) do |conf|
+          conf.readline = true
+          conf.echo = '*' if secret
+        end
+      end
+
+      def format_options(prompt, choices)
+        choices_as_string_options = ''.dup
+        choices.each_with_index { |choice, index| choices_as_string_options << "#{index + 1}. #{choice}\n" }
+        "#{prompt}\n#{choices_as_string_options.strip}"
+      end
+
+      def format_selection(choices, index, with_index)
+        response = { value: choices[index] }
+        response[:index] = index if with_index
+        response
+      end
+
+      def recurse(prompt, choices, options)
+        puts "This question is required.\n\n"
+        choices.nil? ? ask(prompt, options) : ask(prompt, choices, options)
+      end
+
+      private def highline
+        @highline ||= HighLine.new
+      end
+    end
+  end
+end

data/lib/highline_wrapper/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class HighlineWrapper
-  VERSION = '0.1.0'
+  VERSION = '1.0.0'
 end

data/lib/highline_wrapper/yes_no_question.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'question'
+
+class HighlineWrapper
+  class YesNoQuestion < Question
+    class << self
+      def ask(prompt, options)
+        answer = ask_highline(prompt).to_s.downcase
+        puts
+
+        return parse(answer, prompt, options) unless answer.empty?
+        return recurse(prompt, nil, options) if options[:required]
+
+        options[:default]
+      end
+
+      def parse(answer, prompt, options)
+        return true if answer.include?('y')
+        return false if answer.include?('n')
+
+        recurse(prompt, nil, options)
+      end
+    end
+  end
+end

data/spec/highline_wrapper/checkbox_question_spec.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'highline_wrapper'
+
+describe HighlineWrapper::CheckboxQuestion do
+  let(:choices) { %w[one two three] }
+  let(:response) { double(:response, readline: true, to_i: 3) }
+  let(:highline) { double(:highline_cli, ask: response) }
+
+  before do
+    allow(HighLine).to receive(:new).and_return(highline)
+    allow(subject).to receive(:puts)
+  end
+
+  after do
+    HighlineWrapper::CheckboxQuestion.instance_variable_set('@highline', nil)
+  end
+
+  subject { HighlineWrapper::CheckboxQuestion }
+
+  context 'with the options as defaults' do
+    let(:options) do
+      {
+        with_indexes: false,
+        defaults: [],
+        required: false
+      }
+    end
+
+    it 'should ask the highline client ask' do
+      expect(highline).to receive(:ask)
+      subject.ask(Faker::Lorem.sentence, choices, options)
+    end
+
+    it 'should return the value the user selects' do
+      allow(highline).to receive(:ask).and_return('1,3')
+      resp = subject.ask(Faker::Lorem.sentence, choices, options)
+      expect(resp).to eq([{ value: 'one' }, { value: 'three' }])
+    end
+
+    it 'should return empty array if the user skips' do
+      allow(highline).to receive(:ask).and_return('')
+      resp = subject.ask(Faker::Lorem.sentence, choices, options)
+      expect(resp).to eq([])
+    end
+  end
+
+  context 'with required set to true' do
+    context 'with_indexes set to false' do
+      let(:options) do
+        {
+          with_indexes: false,
+          defaults: [],
+          required: true
+        }
+      end
+
+      it 'should return the value the user selects' do
+        allow(highline).to receive(:ask).and_return('1,2')
+        resp = subject.ask(Faker::Lorem.sentence, choices, options)
+        expect(resp).to eq([{ value: 'one' }, { value: 'two' }])
+      end
+
+      it 'should recurse multiple times if the user skips' do
+        allow(highline).to receive(:ask).and_return('', '', '3')
+        expect(subject).to receive(:ask).exactly(3).times.and_call_original
+        subject.ask(Faker::Lorem.sentence, choices, options)
+      end
+    end
+
+    context 'with_indexes set to true' do
+      let(:options) do
+        {
+          with_indexes: true,
+          defaults: [],
+          required: true
+        }
+      end
+
+      it 'should return the value the user selects' do
+        allow(highline).to receive(:ask).and_return('1, 3')
+        resp = subject.ask(Faker::Lorem.sentence, choices, options)
+        expect(resp).to eq([{ value: 'one', index: 0 }, { value: 'three', index: 2 }])
+      end
+
+      it 'should recurse multiple times if the user skips' do
+        allow(highline).to receive(:ask).and_return('', '', '3')
+        expect(subject).to receive(:ask).exactly(3).times.and_call_original
+        subject.ask(Faker::Lorem.sentence, choices, options)
+      end
+    end
+  end
+
+  context 'with required set to false' do
+    context 'with_indexes set to false' do
+      context 'with defaults set' do
+        let(:options) do
+          {
+            with_indexes: false,
+            defaults: ['two'],
+            required: false
+          }
+        end
+
+        it 'should return the value the user selects' do
+          allow(highline).to receive(:ask).and_return('1, 2')
+          resp = subject.ask(Faker::Lorem.sentence, choices, options)
+          expect(resp).to eq([{ value: 'one' }, { value: 'two' }])
+        end
+
+        it 'should return the default if the user skips' do
+          allow(highline).to receive(:ask).and_return('')
+          resp = subject.ask(Faker::Lorem.sentence, choices, options)
+          expect(resp).to eq([{ value: 'two' }])
+        end
+      end
+
+      context 'with defaults set to []' do
+        let(:options) do
+          {
+            with_indexes: false,
+            defaults: [],
+            required: false
+          }
+        end
+
+        it 'should return the value the user selects' do
+          allow(highline).to receive(:ask).and_return('1,3')
+          resp = subject.ask(Faker::Lorem.sentence, choices, options)
+          expect(resp).to eq([{ value: 'one' }, { value: 'three' }])
+        end
+
+        it 'should return nil if the user skips' do
+          allow(highline).to receive(:ask).and_return('')
+          resp = subject.ask(Faker::Lorem.sentence, choices, options)
+          expect(resp).to eq([])
+        end
+      end
+    end
+
+    context 'with_indexes set to true' do
+      context 'with default set' do
+        let(:options) do
+          {
+            with_indexes: true,
+            defaults: ['two'],
+            required: false
+          }
+        end
+
+        it 'should return the value the user selects' do
+          allow(highline).to receive(:ask).and_return('1,2')
+          resp = subject.ask(Faker::Lorem.sentence, choices, options)
+          expect(resp).to eq([{ value: 'one', index: 0 }, { value: 'two', index: 1 }])
+        end
+
+        it 'should return the default if the user skips' do
+          allow(highline).to receive(:ask).and_return('')
+          resp = subject.ask(Faker::Lorem.sentence, choices, options)
+          expect(resp).to eq([{ value: 'two', index: 1 }])
+        end
+      end
+
+      context 'with default nil' do
+        let(:options) do
+          {
+            with_indexes: true,
+            defaults: [],
+            required: false
+          }
+        end
+
+        it 'should return the value the user selects' do
+          allow(highline).to receive(:ask).and_return('1')
+          resp = subject.ask(Faker::Lorem.sentence, choices, options)
+          expect(resp).to eq([{ value: 'one', index: 0 }])
+        end
+
+        it 'should return [] if the user skips' do
+          allow(highline).to receive(:ask).and_return('')
+          resp = subject.ask(Faker::Lorem.sentence, choices, options)
+          expect(resp).to eq([])
+        end
+      end
+    end
+  end
+end

data/spec/highline_wrapper/multiple_choice_question_spec.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'highline_wrapper'
+
+describe HighlineWrapper::MultipleChoiceQuestion do
+  let(:choices) { %w[one two three] }
+  let(:response) { double(:response, readline: true, to_i: 3) }
+  let(:highline) { double(:highline_cli, ask: response) }
+
+  before do
+    allow(HighLine).to receive(:new).and_return(highline)
+    allow(subject).to receive(:puts)
+  end
+
+  after do
+    HighlineWrapper::MultipleChoiceQuestion.instance_variable_set('@highline', nil)
+  end
+
+  subject { HighlineWrapper::MultipleChoiceQuestion }
+
+  context 'with the options as defaults' do
+    let(:options) do
+      {
+        with_index: false,
+        default: nil,
+        required: false
+      }
+    end
+
+    it 'should ask the highline client ask' do
+      expect(highline).to receive(:ask)
+      subject.ask(Faker::Lorem.sentence, choices, options)
+    end
+
+    it 'should return the value the user selects' do
+      allow(highline).to receive(:ask).and_return(1)
+      resp = subject.ask(Faker::Lorem.sentence, choices, options)
+      expect(resp).to eq({ value: 'one' })
+    end
+
+    it 'should return nil if the user skips' do
+      allow(highline).to receive(:ask).and_return(0)
+      resp = subject.ask(Faker::Lorem.sentence, choices, options)
+      expect(resp).to eq(nil)
+    end
+  end
+
+  context 'with required set to true' do
+    context 'with_index set to false' do
+      let(:options) do
+        {
+          with_index: false,
+          default: Faker::Lorem.word,
+          required: true
+        }
+      end
+
+      it 'should return the value the user selects' do
+        allow(highline).to receive(:ask).and_return(1)
+        resp = subject.ask(Faker::Lorem.sentence, choices, options)
+        expect(resp).to eq({ value: 'one' })
+      end
+
+      it 'should recurse multiple times if the user skips' do
+        allow(highline).to receive(:ask).and_return(0, 0, 3)
+        expect(subject).to receive(:ask).exactly(3).times.and_call_original
+        subject.ask(Faker::Lorem.sentence, choices, options)
+      end
+    end
+
+    context 'with_index set to true' do
+      let(:options) do
+        {
+          with_index: true,
+          default: nil,
+          required: true
+        }
+      end
+
+      it 'should return the value the user selects' do
+        allow(highline).to receive(:ask).and_return(1)
+        resp = subject.ask(Faker::Lorem.sentence, choices, options)
+        expect(resp).to eq({ value: 'one', index: 0 })
+      end
+
+      it 'should recurse multiple times if the user skips' do
+        allow(highline).to receive(:ask).and_return(0, 0, 3)
+        expect(subject).to receive(:ask).exactly(3).times.and_call_original
+        subject.ask(Faker::Lorem.sentence, choices, options)
+      end
+    end
+  end
+
+  context 'with required set to false' do
+    context 'with_index set to false' do
+      context 'with default set' do
+        let(:options) do
+          {
+            with_index: false,
+            default: 'two',
+            required: false
+          }
+        end
+
+        it 'should return the value the user selects' do
+          allow(highline).to receive(:ask).and_return(1)
+          resp = subject.ask(Faker::Lorem.sentence, choices, options)
+          expect(resp).to eq({ value: 'one' })
+        end
+
+        it 'should return the default if the user skips' do
+          allow(highline).to receive(:ask).and_return(0)
+          resp = subject.ask(Faker::Lorem.sentence, choices, options)
+          expect(resp).to eq({ value: 'two' })
+        end
+      end
+
+      context 'with default nil' do
+        let(:options) do
+          {
+            with_index: false,
+            default: nil,
+            required: false
+          }
+        end
+
+        it 'should return the value the user selects' do
+          allow(highline).to receive(:ask).and_return(1)
+          resp = subject.ask(Faker::Lorem.sentence, choices, options)
+          expect(resp).to eq({ value: 'one' })
+        end
+
+        it 'should return nil if the user skips' do
+          allow(highline).to receive(:ask).and_return(0)
+          resp = subject.ask(Faker::Lorem.sentence, choices, options)
+          expect(resp).to eq(nil)
+        end
+      end
+    end
+
+    context 'with_index set to true' do
+      context 'with default set' do
+        let(:options) do
+          {
+            with_index: true,
+            default: 'two',
+            required: false
+          }
+        end
+
+        it 'should return the value the user selects' do
+          allow(highline).to receive(:ask).and_return(1)
+          resp = subject.ask(Faker::Lorem.sentence, choices, options)
+          expect(resp).to eq({ value: 'one', index: 0 })
+        end
+
+        it 'should return the default if the user skips' do
+          allow(highline).to receive(:ask).and_return(0)
+          resp = subject.ask(Faker::Lorem.sentence, choices, options)
+          expect(resp).to eq({ value: 'two', index: 1 })
+        end
+      end
+
+      context 'with default nil' do
+        let(:options) do
+          {
+            with_index: true,
+            default: nil,
+            required: false
+          }
+        end
+
+        it 'should return the value the user selects' do
+          allow(highline).to receive(:ask).and_return(1)
+          resp = subject.ask(Faker::Lorem.sentence, choices, options)
+          expect(resp).to eq({ value: 'one', index: 0 })
+        end
+
+        it 'should return nil if the user skips' do
+          allow(highline).to receive(:ask).and_return(0)
+          resp = subject.ask(Faker::Lorem.sentence, choices, options)
+          expect(resp).to eq(nil)
+        end
+      end
+    end
+  end
+end