infopark-user_io 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0c95a85359de4b5840ee1053f7e9abc83d8b91988ac1f7d9611c9f9f8d92f7d
-  data.tar.gz: 68444632af92c73fbd16368b1a4f58142dcaf4c1e5d348e7b52d75c657d286f5
+  metadata.gz: b20bdfdfb2bd29180da2445be83e82295a71b4a30276450351c08ef114ed9da5
+  data.tar.gz: cfe242fc1e3a48b1c0e2b7d0ab40d8663178b6425f9e8b4215c13a67bef85b29
 SHA512:
-  metadata.gz: cf5deca658e0d11c2d6c00b1dba29f87a2515749c6e01c2da1c5a39033a1d35a7c847d2375dd23f6f971c1a8359233f1d3ff339819216ae369a89e89e5b70694
-  data.tar.gz: 0e1f7369c00f4b06d66c9e0f396b1966e474a964d8a3a7d8dce05856da575ea31c37c3653217048949e163e0ad203f2db643f124e4e531b269c678799a8efe2e
+  metadata.gz: 4d75731717e150e66512d1aecab2193938aa159cb276eaa9cae1abbae05753d88559e01b57216f210dfca8f3163a5cb5bee699593e1d5f740e51e7e95c6c3037
+  data.tar.gz: cb512e8b47045e191bcda99ce905b0c5e8a8dffefbd9f489ee0b543841bd75cef8e473e31caa9eddb5caebd97a67c7b5b85a9e91b1ef032894fa443e1ecd9bc2

data/lib/infopark/user_io/global.rb

@@ -3,7 +3,7 @@
 require_relative "../user_io"
 
 module Infopark
-  module UserIO
+  class UserIO
     module Global
       def user_io
         Infopark::UserIO.global

data/lib/infopark/user_io/version.rb

@@ -2,6 +2,6 @@
 
 module Infopark
   class UserIO
-    VERSION = "1.3.0"
+    VERSION = "1.4.0"
   end
 end

data/lib/infopark/user_io.rb

@@ -76,88 +76,39 @@ module Infopark
       @line_pending = {}
     end
 
-    def tell(*texts, newline: true, **line_options)
-      lines = texts.flatten.map {|text| text.to_s.split("\n", -1) }.flatten
-
-      lines[0...-1].each {|line| tell_line(line, **line_options) }
-      tell_line(lines.last, newline:, **line_options)
-    end
-
-    def tell_pty_stream(stream, **color_options)
-      color_prefix, color_postfix = compute_color(**color_options)
-      write_raw(output_prefix) unless line_pending?
-      write_raw(color_prefix)
-      nl_pending = false
-      uncolored_prefix = "#{color_postfix}#{output_prefix}#{color_prefix}"
-      until stream.eof?
-        chunk = stream.read_nonblock(100)
-        next if chunk.empty?
-
-        write_raw("\n#{uncolored_prefix}") if nl_pending
-        chunk.chop! if (nl_pending = chunk.end_with?("\n"))
-        chunk.gsub!(/([\r\n])/, "\\1#{uncolored_prefix}")
-        write_raw(chunk)
-      end
-      write_raw("\n") if nl_pending
-      write_raw(color_postfix)
-      line_pending!(false)
-    end
-
-    def warn(*text)
-      tell(*text, color: :yellow, bright: true)
-    end
-
-    def tell_error(e, **options)
-      tell(e, **options, color: :red, bright: true)
-      tell(e.backtrace, **options, color: :red) if Exception === e
+    def <<(msg)
+      tell(msg.chomp, newline: msg.end_with?("\n"))
     end
 
-    def acknowledge(*text)
-      tell("-" * 80)
-      tell(*text, color: :cyan, bright: true)
-      tell("-" * 80)
-      tell("Please press ENTER to continue.")
+    def acknowledge(*texts, **options)
+      tell("-" * 80, **options)
+      tell(*texts, **options, color: :cyan, bright: true)
+      tell("-" * 80, **options)
+      tell("Please press ENTER to continue.", **options)
       read_line
+      nil
     end
 
-    def ask(*text, default: nil, expected: "yes")
+    def ask(*texts, default: nil, expected: "yes", **tell_options)
       # TODO
       # - implementation error if default not boolean or nil
       # - implementation error if expected not "yes" or "no"
-      tell("-" * 80)
-      tell(*text, color: :cyan, bright: true)
-      tell("-" * 80)
+      tell("-" * 80, **tell_options)
+      tell(*texts, **tell_options, color: :cyan, bright: true)
+      tell("-" * 80, **tell_options)
       default_answer = default ? "yes" : "no" unless default.nil?
-      tell("(yes/no) #{default_answer && "[#{default_answer}] "}> ", newline: false)
-      until %w(yes no).include?(answer = read_line.strip.downcase)
+      tell("(yes/no) #{default_answer && "[#{default_answer}] "}> ", **tell_options, newline: false)
+      until %w(yes no).include?((answer = read_line.strip.downcase))
         if answer.empty?
           answer = default_answer
           break
         end
-        tell("I couldn't understand “#{answer}”.", newline: false, color: :red, bright: true)
-        tell(" > ", newline: false)
+        tell("I couldn't understand “#{answer}”.", **tell_options, newline: false, color: :red, bright: true)
+        tell(" > ", **tell_options, newline: false)
       end
       answer == expected
     end
 
-    def listen(prompt = nil, **options)
-      prompt << " " if prompt
-      tell("#{prompt}> ", **options, newline: false)
-      read_line.strip
-    end
-
-    def confirm(*text)
-      ask(*text) or raise(Aborted)
-    end
-
-    def new_progress(label)
-      Progress.new(label, self)
-    end
-
-    def start_progress(label)
-      new_progress(label).tap(&:start)
-    end
-
     def background_other_threads
       return if @foreground_thread
 
@@ -165,22 +116,8 @@ module Infopark
       @foreground_thread = Thread.current
     end
 
-    def foreground
-      return unless @foreground_thread
-
-      @background_data.each(&$stdout.method(:write))
-      @foreground_thread = nil
-      # take over line_pending from background
-      @line_pending[false] = @line_pending[true]
-      @line_pending[true] = false
-    end
-
-    def <<(msg)
-      tell(msg.chomp, newline: msg.end_with?("\n"))
-    end
-
-    def tty?
-      $stdout.tty?
+    def confirm(*text, **options)
+      ask(*text, **options) or raise(Aborted)
     end
 
     def edit_file(kind_of_data, filename = nil, template: nil)
@@ -200,6 +137,26 @@ module Infopark
       File.read(filename)
     end
 
+    def foreground
+      return unless @foreground_thread
+
+      @background_data.each(&$stdout.method(:write))
+      @foreground_thread = nil
+      # take over line_pending from background
+      @line_pending[false] = @line_pending[true]
+      @line_pending[true] = false
+    end
+
+    def listen(prompt = nil, **options)
+      prompt << " " if prompt
+      tell("#{prompt}> ", **options, newline: false)
+      read_line.strip
+    end
+
+    def new_progress(label)
+      Progress.new(label, self)
+    end
+
     def select(description, items, item_describer: :to_s, default: nil)
       return if items.empty?
 
@@ -247,50 +204,54 @@ module Infopark
       choice
     end
 
-    private
-
-    def background?
-      !!@foreground_thread && @foreground_thread != Thread.current
+    def start_progress(label)
+      new_progress(label).tap(&:start)
     end
 
-    def wait_for_foreground
-      sleep(0.1) while background?
-    end
+    def tell(*texts, newline: true, **line_options)
+      lines = texts.flatten.map {|text| text.to_s.split("\n", -1) }.flatten
 
-    def output_prefix
-      @output_prefix || @output_prefix_proc&.call
+      lines[0...-1].each {|line| tell_line(line, **line_options) }
+      tell_line(lines.last, newline:, **line_options)
     end
 
-    def read_line
-      wait_for_foreground if background?
-      @line_pending[false] = false
-      $stdin.gets.chomp
+    def tell_error(e, **options)
+      tell(e, **options, color: :red, bright: true)
+      tell(e.backtrace, **options, color: :red) if Exception === e
     end
 
-    def tell_line(line, newline: true, prefix: true, **color_options)
-      line_prefix, line_postfix = compute_color(**color_options)
-      prefix = false if line_pending?
-
-      out_line = "#{output_prefix if prefix}#{line_prefix}#{line}#{line_postfix}#{"\n" if newline}"
-      write_raw(out_line)
+    def tell_pty_stream(stream, **color_options)
+      color_prefix, color_postfix = compute_color(**color_options)
+      write_raw(output_prefix) unless line_pending?
+      write_raw(color_prefix)
+      nl_pending = false
+      uncolored_prefix = "#{color_postfix}#{output_prefix}#{color_prefix}"
+      until stream.eof?
+        chunk = stream.read_nonblock(100)
+        next if chunk.empty?
 
-      line_pending!(!newline)
+        write_raw("\n#{uncolored_prefix}") if nl_pending
+        chunk.chop! if (nl_pending = chunk.end_with?("\n"))
+        chunk.gsub!(/([\r\n])/, "\\1#{uncolored_prefix}")
+        write_raw(chunk)
+      end
+      write_raw("\n") if nl_pending
+      write_raw(color_postfix)
+      line_pending!(false)
     end
 
-    def write_raw(bytes)
-      if background?
-        @background_data << bytes
-      else
-        $stdout.write(bytes)
-      end
+    def tty?
+      $stdout.tty?
     end
 
-    def line_pending?
-      @line_pending[background?]
+    def warn(*texts, **options)
+      tell(*texts, **options, color: :yellow, bright: true)
     end
 
-    def line_pending!(value)
-      @line_pending[background?] = value
+    private
+
+    def background?
+      !!@foreground_thread && @foreground_thread != Thread.current
     end
 
     def compute_color(**options)
@@ -305,11 +266,39 @@ module Infopark
       "\033[#{parameters.join(';')}#{function}"
     end
 
+    def line_pending?
+      @line_pending[background?]
+    end
+
+    def line_pending!(value)
+      @line_pending[background?] = value
+    end
+
+    def output_prefix
+      @output_prefix || @output_prefix_proc&.call
+    end
+
+    def read_line
+      wait_for_foreground if background?
+      @line_pending[false] = false
+      $stdin.gets.chomp
+    end
+
     # SGR: Select Graphic Rendition … far too long for a function name ;)
     def sgr_sequence(*parameters)
       control_sequence(*parameters, :m)
     end
 
+    def tell_line(line, newline: true, prefix: true, **color_options)
+      line_prefix, line_postfix = compute_color(**color_options)
+      prefix = false if line_pending?
+
+      out_line = "#{output_prefix if prefix}#{line_prefix}#{line}#{line_postfix}#{"\n" if newline}"
+      write_raw(out_line)
+
+      line_pending!(!newline)
+    end
+
     def text_color(color: nil, bright: nil, faint: nil, italic: nil, underline: nil)
       return if color.nil? && bright.nil?
 
@@ -348,6 +337,18 @@ module Infopark
       end
       sgr_sequence(*sequence)
     end
+
+    def wait_for_foreground
+      sleep(0.1) while background?
+    end
+
+    def write_raw(bytes)
+      if background?
+        @background_data << bytes
+      else
+        $stdout.write(bytes)
+      end
+    end
   end
 end
 

data/spec/user_io_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "securerandom"
+
 module Infopark
   RSpec.describe(UserIO) do
     let(:options) { {} }
@@ -28,19 +30,35 @@ module Infopark
     end
 
     describe "#acknowledge" do
-      before { allow($stdin).to(receive(:gets).and_return("\n")) }
+      subject(:acknowledge) { user_io.acknowledge(*ack_texts, **ack_options) }
 
-      let(:message) { "Some important statement." }
+      before do
+        allow($stdin).to(receive(:gets).and_return("\n"))
+        allow(user_io).to(receive(:tell))
+      end
 
-      subject(:acknowledge) { user_io.acknowledge(message) }
+      let(:ack_options) do
+        [
+          {newline: true},
+          {prefix: "foo", newline: false},
+          {},
+        ].sample
+      end
+      let(:ack_texts) do
+        [
+          ["Some important statement."],
+          ["Some", "important", "statement!"],
+          [],
+        ].sample
+      end
 
-      it "presents the message (colorized)" do
-        expect($stdout).to(receive(:write).with("\e[1;36mSome important statement.\e[22;39m\n"))
+      it "tells the message (colorized)" do
+        expect(user_io).to(receive(:tell).with(*ack_texts, **ack_options, color: :cyan, bright: true))
         acknowledge
       end
 
       it "asks for pressing “Enter”" do
-        expect($stdout).to(receive(:write).with("Please press ENTER to continue.\n"))
+        expect(user_io).to(receive(:tell).with("Please press ENTER to continue.", **ack_options))
         acknowledge
       end
 
@@ -48,21 +66,73 @@ module Infopark
         expect($stdin).to(receive(:gets).and_return("\n"))
         acknowledge
       end
+
+      it "returns nil" do
+        expect(acknowledge).to(be_nil)
+      end
     end
 
     describe "#ask" do
-      before { allow($stdin).to(receive(:gets).and_return("yes\n")) }
+      subject(:ask) { user_io.ask(*ask_texts, **ask_options.merge(tell_options)) }
 
+      before do
+        allow($stdin).to(receive(:gets).and_return("#{answer}\n"))
+        allow(user_io).to(receive(:tell))
+      end
+
+      let(:answer) { "yes" }
+      let(:ask_texts) do
+        [
+          ["do you want to?"],
+          ["do", "you", "want", "to?"],
+          [],
+        ].sample
+      end
       let(:ask_options) { {} }
-      let(:question) { "do you want to?" }
+      let(:tell_options) do
+        [
+          {italic: true},
+          {prefix: "foo", bold: false},
+          {},
+        ].sample
+      end
 
-      subject(:ask) { user_io.ask(*Array(question), **ask_options) }
+      shared_examples_for "any question" do |invert_answer: false|
+        it "tells the message (colorized)" do
+          expect(user_io).to(receive(:tell).with(*ask_texts, **tell_options, color: :cyan, bright: true))
+          ask
+        end
+
+        it "requests input" do
+          expect($stdin).to(receive(:gets).and_return("\n"))
+          ask
+        end
+
+        context "when answer is “yes”" do
+          let(:answer) { "yes" }
+
+          it { is_expected.to(be(invert_answer ? false : true))}
+        end
+
+        context "when answer is “no”" do
+          let(:answer) { "no" }
+
+          it { is_expected.to(be(invert_answer ? true : false))}
+        end
 
-      shared_examples_for "any question" do
         # TODO
         # it_behaves_like "handling valid answer"
         # it_behaves_like "handling invalid input"
-        # it_behaves_like "printing prefix on every line"
+      end
+
+      it "asks for answer" do
+        expect(user_io).to(receive(:tell).with("(yes/no) > ", **tell_options, newline: false))
+        ask
+      end
+
+      it "returns “false” on empty input" do
+        expect($stdin).to(receive(:gets).and_return("\n"))
+        expect(ask).to(be(false))
       end
 
       context "with default" do
@@ -72,7 +142,7 @@ module Infopark
           let(:default_value) { true }
 
           it "presents default answer “yes”" do
-            expect($stdout).to(receive(:write).with("(yes/no) [yes] > "))
+            expect(user_io).to(receive(:tell).with("(yes/no) [yes] > ", **tell_options, newline: false))
             ask
           end
 
@@ -88,7 +158,7 @@ module Infopark
           let(:default_value) { false }
 
           it "presents default answer “no”" do
-            expect($stdout).to(receive(:write).with("(yes/no) [no] > "))
+            expect(user_io).to(receive(:tell).with("(yes/no) [no] > ", **tell_options, newline: false))
             ask
           end
 
@@ -127,7 +197,7 @@ module Infopark
         context "“no”" do
           let(:expected_value) { "no" }
 
-          it_behaves_like "any question"
+          it_behaves_like "any question", invert_answer: true
 
           it "returns “true” when answering “no”" do
             expect($stdin).to(receive(:gets).and_return("no\n"))
@@ -146,6 +216,53 @@ module Infopark
       end
     end
 
+    describe "#confirm" do
+      subject(:confirm) { user_io.confirm(*confirm_texts, **confirm_options) }
+
+      before { allow(user_io).to(receive(:ask)).and_return(ask_result) }
+
+      let(:ask_result) { true }
+      let(:confirm_options) do
+        [
+          {expected: "yes"},
+          {default: "foo", expected: "bar"},
+          {},
+        ].sample
+      end
+      let(:confirm_texts) do
+        [
+          %w[foo bar],
+          %w[baz],
+          [],
+        ].sample
+      end
+
+      it "delegates to #ask" do
+        confirm
+        if confirm_texts.empty? && confirm_options.empty?
+          expect(user_io).to(have_received(:ask).with(no_args))
+        else
+          expect(user_io).to(have_received(:ask).with(*confirm_texts, **confirm_options))
+        end
+      end
+
+      context "when #ask returns truthy" do
+        let(:ask_result) { [SecureRandom.hex, 1, true].sample }
+
+        it "returns the result" do
+          expect(confirm).to(be(ask_result))
+        end
+      end
+
+      context "when #ask returns falsey" do
+        let(:ask_result) { [nil, false].sample }
+
+        it "aborts" do
+          expect { confirm }.to(raise_error(UserIO::Aborted))
+        end
+      end
+    end
+
     describe "#select" do
       before { allow($stdin).to(receive(:gets).and_return("1\n")) }
 
@@ -206,7 +323,7 @@ module Infopark
     describe "#tell_pty_stream" do
       let(:color_options) { {} }
       let(:stream) { instance_double(IO) }
-      let(:data) { "test data" }
+      let(:data) { +"test data" }
 
       subject(:tell) { user_io.tell_pty_stream(stream, **color_options) }
 
@@ -221,7 +338,7 @@ module Infopark
       it "tells all data from stream in non blocking chunks" do
         expect(stream).to(receive(:eof?).and_return(false, false, false, true))
         expect(stream).to(receive(:read_nonblock).with(100)
-            .and_return("first\nchunk", "second chunk", "\nlast chunk"))
+            .and_return(+"first\nchunk", +"second chunk", +"\nlast chunk"))
         expect($stdout).to(receive(:write).with("first\nchunk"))
         expect($stdout).to(receive(:write).with("second chunk"))
         expect($stdout).to(receive(:write).with("\nlast chunk"))
@@ -261,7 +378,7 @@ module Infopark
         end
 
         context "when stream contains carriage return" do
-          let(:data) { "some\rdata\rwith\rCRs" }
+          let(:data) { +"some\rdata\rwith\rCRs" }
 
           it "writes the prefix right after the CR" do
             expect($stdout).to(receive(:write).with("[the prefix] ").ordered)
@@ -289,7 +406,7 @@ module Infopark
         end
 
         context "when stream contains newline" do
-          let(:data) { "some\ndata\nwith\nNLs" }
+          let(:data) { +"some\ndata\nwith\nNLs" }
 
           it "writes the prefix right after the NL" do
             expect($stdout).to(receive(:write).with("[the prefix] ").ordered)
@@ -317,7 +434,7 @@ module Infopark
 
           context "when stream ends with newline" do
             # includes an empty chunk to verify, that they don't consume the pending NL
-            let(:data) { ["some\n", "data\n", "with\n", "", "NLs\n", ""] }
+            let(:data) { [+"some\n", +"data\n", +"with\n", +"", +"NLs\n", +""] }
 
             it "does not write prefix after the last newline" do
               expect($stdout).to(receive(:write).with("[the prefix] ").ordered)
@@ -354,7 +471,7 @@ module Infopark
         end
 
         context "when data does not end with newline" do
-          let(:data) { "foo" }
+          let(:data) { +"foo" }
 
           it "writes prefix on next output nevertheless" do
             expect($stdout).to(receive(:write).with("[the prefix] ").ordered)
@@ -388,20 +505,23 @@ module Infopark
       context "when in background" do
         let(:color_options) { {color: :yellow} }
         let(:options) { {output_prefix: "foo"} }
-        let(:data) { ["data\n", "in\nchunks", "", "yo\n", ""] }
+        let(:data) { [+"data\n", +"in\nchunks", +"", +"yo\n", +""] }
 
-        let!(:foreground_thread) do
-          @finished = false
-          Thread.new do
+        before do
+          @fg_in = Thread::Queue.new
+          @fg_out = Thread::Queue.new
+          @fg_thread = Thread.new do
             user_io.background_other_threads
-            sleep(0.1) until @finished
+            @fg_out.push(:other_backgrounded)
+            @fg_in.pop
             user_io.foreground
           end
         end
 
-        after { foreground_thread.kill.join }
+        after { @fg_thread.kill.join }
 
         it "holds back the output until coming back to foreground" do
+          @fg_out.pop(timeout: 1)
           expect($stdout).to_not(receive(:write))
           tell
           RSpec::Mocks.space.proxy_for($stdout).reset
@@ -413,10 +533,37 @@ module Infopark
           expect($stdout).to(receive(:write).with("yo").ordered)
           expect($stdout).to(receive(:write).with("\n").ordered)
           expect($stdout).to(receive(:write).with("\e[22;39m").ordered)
-          @finished = true
-          foreground_thread.join
+          @fg_in.push(:background_done)
+          @fg_thread.join
         end
       end
     end
+
+    describe "#warn" do
+      subject(:warn) { user_io.warn(*warn_texts, **warn_options) }
+
+      before { allow(user_io).to(receive(:tell)).and_return(tell_result) }
+
+      let(:tell_result) { [SecureRandom.hex, nil].sample }
+      let(:warn_options) do
+        [
+          {newline: true},
+          {prefix: "foo", newline: false},
+          {},
+        ].sample
+      end
+      let(:warn_texts) do
+        [
+          %w[foo bar],
+          %w[baz],
+          [],
+        ].sample
+      end
+
+      it "delegates to #tell" do
+        warn
+        expect(user_io).to(have_received(:tell).with(*warn_texts, **warn_options, color: :yellow, bright: true))
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: infopark-user_io
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Tilo Prütz