highline_wrapper 0.1.0 → 1.2.2

data/lib/highline_wrapper/checkbox_question.rb

@@ -0,0 +1,42 @@
+# 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))
+
+        return format_multiple_selections(choices, indices, options[:with_indexes]) unless indices.empty?
+        return recurse(prompt, choices, options) if options[:required]
+        return return_empty_defaults(options) if options[:defaults].empty?
+
+        return_defaults(choices, options)
+      end
+
+      private def ask_highline(prompt)
+        indices = []
+        super(prompt).to_s.split(',').each { |i| indices << i.strip.to_i - 1 }
+        indices
+      end
+
+      private def return_defaults(choices, options)
+        options[:default_indexes] = options[:defaults].map { |d| choices.index(d) }
+        print_default_message(options, choices) if options[:indicate_default_message]
+        format_multiple_selections(choices, options[:default_indexes], options[:with_indexes])
+      end
+
+      private def print_default_message(options, choices)
+        defaults = options[:default_indexes].map { |i| "#{i + 1}. #{choices[i]}".strip }.join(', ')
+        puts "--- Defaults selected: #{defaults} ---"
+      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,29 @@
+# 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
+
+        return format_selection(choices, index, options[:with_index]) unless index == -1
+        return recurse(prompt, choices, options) if options[:required]
+        return return_empty_defaults(options) if options[:default].nil?
+
+        return_defaults(choices, options)
+      end
+
+      private def return_defaults(choices, options)
+        options[:default_index] = choices.index(options[:default])
+        print_default_message(options) if options[:indicate_default_message]
+        format_selection(choices, options[:default_index], options[:with_index])
+      end
+
+      private def print_default_message(options)
+        puts "--- Default selected: #{options[:default_index] + 1}. #{options[:default]} ---"
+      end
+    end
+  end
+end

data/lib/highline_wrapper/open_ended_question.rb

@@ -0,0 +1,27 @@
+# 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
+
+        return answer unless answer.empty?
+        return recurse(prompt, nil, options) if options[:required]
+
+        print_default_message(options) if options[:indicate_default_message]
+        options[:default]
+      end
+
+      private def print_default_message(options)
+        if !options[:secret]
+          puts "--- Default selected: #{options[:default].empty? ? 'EMPTY' : options[:default]} ---"
+        elsif options[:secret]
+          puts '--- Default selected: HIDDEN ---'
+        end
+      end
+    end
+  end
+end

data/lib/highline_wrapper/question.rb

@@ -0,0 +1,40 @@
+# 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 ---'
+        choices.nil? ? ask(prompt, options) : ask(prompt, choices, options)
+      end
+
+      def return_empty_defaults(options)
+        puts '--- Default selected: EMPTY ---' if options[:indicate_default_message]
+        options[:defaults] || options[:default]
+      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.2.2'
 end

data/lib/highline_wrapper/yes_no_question.rb

@@ -0,0 +1,34 @@
+# 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
+
+        return parse(answer, prompt, options) unless answer.empty?
+        return recurse(prompt, nil, options) if options[:required]
+
+        print_default_message(options) if options[:indicate_default_message]
+        options[:default]
+      end
+
+      private def parse(answer, prompt, options)
+        case answer
+        when 'yes', 'y'
+          true
+        when 'no', 'n'
+          false
+        else
+          recurse(prompt, nil, options)
+        end
+      end
+
+      private def print_default_message(options)
+        puts "--- Default selected: #{options[:default] ? 'YES' : 'NO'} ---"
+      end
+    end
+  end
+end

data/spec/highline_wrapper/checkbox_question_spec.rb

@@ -0,0 +1,226 @@
+# 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
+
+    it 'should call the return empty defaults if the user skips' do
+      allow(highline).to receive(:ask).and_return('')
+      expect(subject).to receive(:return_empty_defaults)
+      subject.ask(Faker::Lorem.sentence, choices, options)
+    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
+          {
+            indicate_default_message: true,
+            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
+
+        it 'should call to return the defaults if the user skips' do
+          allow(highline).to receive(:ask).and_return('')
+          expect(subject).to receive(:return_defaults).and_call_original
+          expect(subject).to receive(:puts)
+          subject.ask(Faker::Lorem.sentence, choices, options)
+        end
+
+        context 'when the indicate_default_message is false' do
+          let(:options) do
+            {
+              indicate_default_message: false,
+              with_indexes: false,
+              defaults: ['two'],
+              required: false
+            }
+          end
+
+          it 'should call to return the defaults if the user skips' do
+            allow(highline).to receive(:ask).and_return('')
+            expect(subject).to receive(:return_defaults)
+            expect(subject).not_to receive(:puts)
+            subject.ask(Faker::Lorem.sentence, choices, options)
+          end
+        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
+
+        it 'should call the return empty defaults message' do
+          allow(highline).to receive(:ask).and_return('')
+          expect(subject).to receive(:return_empty_defaults)
+          subject.ask(Faker::Lorem.sentence, choices, options)
+        end
+      end
+    end
+  end
+end

data/spec/highline_wrapper/multiple_choice_question_spec.rb

@@ -0,0 +1,226 @@
+# 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
+
+    it 'should call the return empty defaults if the user skips' do
+      allow(highline).to receive(:ask).and_return('')
+      expect(subject).to receive(:return_empty_defaults)
+      subject.ask(Faker::Lorem.sentence, choices, options)
+    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
+          {
+            indicate_default_message: true,
+            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
+
+        it 'should call to return the defaults if the user skips' do
+          allow(highline).to receive(:ask).and_return(0)
+          expect(subject).to receive(:return_defaults).and_call_original
+          expect(subject).to receive(:puts)
+          subject.ask(Faker::Lorem.sentence, choices, options)
+        end
+
+        context 'when the indicate_default_message is false' do
+          let(:options) do
+            {
+              indicate_default_message: false,
+              with_indexes: false,
+              default: 'two',
+              required: false
+            }
+          end
+
+          it 'should call to return the defaults if the user skips' do
+            allow(highline).to receive(:ask).and_return(0)
+            expect(subject).to receive(:return_defaults)
+            expect(subject).not_to receive(:puts)
+            subject.ask(Faker::Lorem.sentence, choices, options)
+          end
+        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
+
+        it 'should call the return empty defaults message' do
+          allow(highline).to receive(:ask).and_return(0)
+          expect(subject).to receive(:return_empty_defaults)
+          subject.ask(Faker::Lorem.sentence, choices, options)
+        end
+      end
+    end
+  end
+end