ego 0.5.0 → 0.6.0

data/spec/ego/plugins/capabilities_spec.rb

@@ -1,8 +1,8 @@
-require 'ego/robot'
+# frozen_string_literal: true
 
-RSpec.describe Ego::Robot, 'with capabilities plug-in' do
-  subject { robot_with_plugin('capabilities') }
+require 'ego/robot'
 
+RSpec.describe Ego::Robot, 'with capabilities plug-in', plugin: 'capabilities' do
   describe '#understand?' do
     it 'is defined on the robot instance' do
       expect(subject.respond_to?(:understand?)).to be true
@@ -13,7 +13,7 @@ RSpec.describe Ego::Robot, 'with capabilities plug-in' do
     end
 
     it 'returns true for queries the robot can handle' do
-      subject.on(/^zzz$/) { }
+      subject.on(/^zzz$/) {}
       expect(subject.understand?('zzz')).to be true
     end
   end

data/spec/ego/plugins/fallback_spec.rb

@@ -1,22 +1,32 @@
+# frozen_string_literal: true
+
 require 'ego/robot'
 
-RSpec.describe Ego::Robot, 'with fallback plug-in' do
-  subject { robot_with_plugin('fallback') }
+RSpec.describe Ego::Robot, 'with fallback plug-in', plugin: 'fallback' do
   let(:unhandlable_query) { 'xxx' }
+  let(:empty_query) { '' }
 
   it { should be_able_to 'help you write plug-ins' }
 
-  it { should_not handle_query :unhandlable_query }
+  it { should_not handle_query unhandlable_query }
 
   it 'prints a hint when a query is unhandled' do
-    expect { subject.handle('xxx') }.to output(
+    expect { subject.handle(unhandlable_query) }.to output(
       /^Ego\.plugin/
     ).to_stdout
   end
 
   it 'prints a hint containing the original query' do
-    expect { subject.handle('xxx') }.to output(
-      /xxx/
+    expect { subject.handle(unhandlable_query) }.to output(
+      Regexp.new(unhandlable_query)
+    ).to_stdout
+  end
+
+  it { should handle_query empty_query }
+
+  it 'prints a message when the query is empty' do
+    expect { subject.handle(empty_query) }.to output(
+      /^(Yes|Hello|\.\.\.)\?$/
     ).to_stdout
   end
 end

data/spec/ego/plugins/robot_io_spec.rb

@@ -1,8 +1,8 @@
-require 'ego/robot'
+# frozen_string_literal: true
 
-RSpec.describe Ego::Robot, 'with robot_io plug-in' do
-  subject { robot_with_plugin('robot_io') }
+require 'ego/robot'
 
+RSpec.describe Ego::Robot, 'with robot_io plug-in', plugin: 'robot_io' do
   it { should be_able_to 'output text to the terminal' }
 
   describe '#verbose?' do

data/spec/ego/plugins/social_spec.rb

@@ -1,8 +1,8 @@
-require 'ego/robot'
+# frozen_string_literal: true
 
-RSpec.describe Ego::Robot, 'with social plug-in' do
-  subject { robot_with_plugin('social') }
+require 'ego/robot'
 
+RSpec.describe Ego::Robot, 'with social plug-in', plugin: 'social' do
   it { should be_able_to 'socialize' }
 
   it { should handle_query 'who are you' }

data/spec/ego/plugins/status_spec.rb

@@ -1,8 +1,8 @@
-require 'ego/robot'
+# frozen_string_literal: true
 
-RSpec.describe Ego::Robot, 'with status plug-in' do
-  subject { robot_with_plugin('status') }
+require 'ego/robot'
 
+RSpec.describe Ego::Robot, 'with status plug-in', plugin: 'status' do
   it { should be_able_to 'report robot status' }
 
   it { should handle_query 'status' }

data/spec/ego/plugins/system_spec.rb

@@ -1,12 +1,12 @@
-require 'ego/robot'
+# frozen_string_literal: true
 
-RSpec.describe Ego::Robot, 'with system plug-in' do
-  subject { robot_with_plugin('system') }
+require 'ego/robot'
 
+RSpec.describe Ego::Robot, 'with system plug-in', plugin: 'system' do
   it { should be_able_to 'execute system commands' }
 
   describe '#system' do
-    let(:args) { ['foo', 'bar'] }
+    let(:args) { %w[foo bar] }
 
     before do
       allow(Kernel).to receive(:system).and_return(true)
@@ -20,7 +20,7 @@ RSpec.describe Ego::Robot, 'with system plug-in' do
 
     it 'calls Kernel.system' do
       expect(Kernel).to receive(:system).with(*args)
-      subject.system *args
+      subject.system(*args)
     end
 
     it 'prints a debug message' do
@@ -28,12 +28,12 @@ RSpec.describe Ego::Robot, 'with system plug-in' do
         'Running system with arguments %s.',
         args
       )
-      subject.system *args
+      subject.system(*args)
     end
 
     it 'prints nothing on success' do
       expect(subject).not_to receive(:alert)
-      subject.system *args
+      subject.system(*args)
     end
 
     it 'prints an alert on error' do
@@ -42,7 +42,7 @@ RSpec.describe Ego::Robot, 'with system plug-in' do
         'Sorry, there was a problem running %s.',
         args.first
       )
-      subject.system *args
+      subject.system(*args)
     end
   end
 

data/spec/ego/printer_spec.rb

@@ -1,122 +1,122 @@
+# frozen_string_literal: true
+
 require 'ego/printer'
 
-module Ego
-  RSpec.describe Printer do
-    let(:verbose_printer) { (Class.new { include Printer; def verbose?; true; end }).new }
-    let(:printer) { (Class.new { include Printer }).new }
+RSpec.describe Ego::Printer do
+  let(:verbose_printer) { (Class.new { include Ego::Printer; def verbose?; true; end }).new }
+  let(:printer) { (Class.new { include Ego::Printer }).new }
 
-    before(:all) { String.disable_colorization = false }
-    after(:all) { String.disable_colorization = true }
+  before(:all) { String.disable_colorization = false }
+  after(:all) { String.disable_colorization = true }
 
-    describe '#puts' do
-      it 'is callable on the module' do
-        expect(described_class.respond_to?(:puts)).to be true
-      end
+  describe '#puts' do
+    it 'is callable on the module' do
+      expect(described_class.respond_to?(:puts)).to be true
+    end
 
-      it 'is private on the instance' do
-        expect(printer.respond_to?(:puts)).to be false
-      end
+    it 'is private on the instance' do
+      expect(printer.respond_to?(:puts)).to be false
+    end
 
-      it 'prints to STDOUT' do
-        expect { described_class.puts 'bar' }.to output("bar\n").to_stdout
-      end
+    it 'prints to STDOUT' do
+      expect { described_class.puts 'bar' }.to output("bar\n").to_stdout
+    end
 
-      it 'concatenates multiple arguments' do
-        expect { described_class.puts 'bar', 'baz' }.to output("bar\nbaz\n").to_stdout
-      end
+    it 'concatenates multiple arguments' do
+      expect { described_class.puts 'bar', 'baz' }.to output("bar\nbaz\n").to_stdout
     end
+  end
 
-    describe '#errs' do
-      it 'is callable on the module' do
-        expect(described_class.respond_to?(:errs)).to be true
-      end
+  describe '#errs' do
+    it 'is callable on the module' do
+      expect(described_class.respond_to?(:errs)).to be true
+    end
 
-      it 'is private on the instance' do
-        expect(printer.respond_to?(:errs)).to be false
-      end
+    it 'is private on the instance' do
+      expect(printer.respond_to?(:errs)).to be false
+    end
 
-      it 'prints to STDERR' do
-        expect { described_class.errs 'bar' }.to output("bar\n").to_stderr
-      end
+    it 'prints to STDERR' do
+      expect { described_class.errs 'bar' }.to output("bar\n").to_stderr
+    end
 
-      it 'concatenates multiple arguments' do
-        expect { described_class.errs 'bar', 'baz' }.to output("bar\nbaz\n").to_stderr
-      end
+    it 'concatenates multiple arguments' do
+      expect { described_class.errs 'bar', 'baz' }.to output("bar\nbaz\n").to_stderr
     end
+  end
 
-    describe '#say' do
-      it 'is not callable on the module' do
-        expect(described_class.respond_to?(:say)).to be false
-      end
+  describe '#say' do
+    it 'is not callable on the module' do
+      expect(described_class.respond_to?(:say)).to be false
+    end
 
-      it 'is callable on the instance' do
-        expect(printer.respond_to?(:say)).to be true
-      end
+    it 'is callable on the instance' do
+      expect(printer.respond_to?(:say)).to be true
+    end
 
-      it 'prints the message to STDOUT bolded with newline' do
-        expect { printer.say('X') }.to output("\e[1;39;49mX\e[0m\n").to_stdout
-      end
+    it 'prints the message to STDOUT bolded with newline' do
+      expect { printer.say('X') }.to output("\e[1;39;49mX\e[0m\n").to_stdout
+    end
 
-      it 'accepts placeholders and replacement strings' do
-        expect { printer.say('Hello, %s.', 'world') }.to output("\e[1;39;49mHello, world.\e[0m\n").to_stdout
-      end
+    it 'accepts placeholders and replacement strings' do
+      expect { printer.say('Hello, %s.', 'world') }.to output("\e[1;39;49mHello, world.\e[0m\n").to_stdout
     end
+  end
 
-    describe '#emote' do
-      it 'is not callable on the module' do
-        expect(described_class.respond_to?(:emote)).to be false
-      end
+  describe '#emote' do
+    it 'is not callable on the module' do
+      expect(described_class.respond_to?(:emote)).to be false
+    end
 
-      it 'is callable on the instance' do
-        expect(printer.respond_to?(:emote)).to be true
-      end
+    it 'is callable on the instance' do
+      expect(printer.respond_to?(:emote)).to be true
+    end
 
-      it 'prints the message to STDOUT with color and asterisks' do
-        expect { printer.emote('FOO') }.to output("\e[0;35;49m*FOO*\e[0m\n").to_stdout
-      end
+    it 'prints the message to STDOUT with color and asterisks' do
+      expect { printer.emote('FOO') }.to output("\e[0;35;49m*FOO*\e[0m\n").to_stdout
     end
+  end
 
-    describe '#alert' do
-      it 'is not callable on the module' do
-        expect(described_class.respond_to?(:alert)).to be false
-      end
+  describe '#alert' do
+    it 'is not callable on the module' do
+      expect(described_class.respond_to?(:alert)).to be false
+    end
 
-      it 'is callable on the instance' do
-        expect(printer.respond_to?(:alert)).to be true
-      end
+    it 'is callable on the instance' do
+      expect(printer.respond_to?(:alert)).to be true
+    end
 
-      it 'prints the message to STDERR with color and newline' do
-        expect { printer.alert('FOO') }.to output("\e[0;91;49mFOO\e[0m\n").to_stderr
-      end
+    it 'prints the message to STDERR with color and newline' do
+      expect { printer.alert('FOO') }.to output("\e[0;91;49mFOO\e[0m\n").to_stderr
+    end
 
-      it 'accepts placeholders and replacement strings' do
-        expect { printer.alert('Error: %s.', 'foo') }.to output("\e[0;91;49mError: foo.\e[0m\n").to_stderr
-      end
+    it 'accepts placeholders and replacement strings' do
+      expect { printer.alert('Error: %s.', 'foo') }.to output("\e[0;91;49mError: foo.\e[0m\n").to_stderr
     end
+  end
 
-    describe '#debug' do
-      it 'is not callable on the module' do
-        expect(described_class.respond_to?(:debug)).to be false
-      end
+  describe '#debug' do
+    it 'is not callable on the module' do
+      expect(described_class.respond_to?(:debug)).to be false
+    end
 
-      it 'is callable on the instance' do
-        expect(printer.respond_to?(:debug)).to be true
-      end
+    it 'is callable on the instance' do
+      expect(printer.respond_to?(:debug)).to be true
+    end
 
-      context 'in verbose instance' do
-        it 'prints the message to STDERR with newline' do
-          expect { verbose_printer.debug('FOO') }.to output("FOO\n").to_stderr
-        end
+    context 'in verbose instance' do
+      it 'prints the message to STDERR with newline' do
+        expect { verbose_printer.debug('FOO') }.to output("FOO\n").to_stderr
+      end
 
-        it 'accepts placeholders and replacement strings' do
-          expect { verbose_printer.debug('Hello, %s.', 'world') }.to output("Hello, world.\n").to_stderr
-        end
+      it 'accepts placeholders and replacement strings' do
+        expect { verbose_printer.debug('Hello, %s.', 'world') }.to output("Hello, world.\n").to_stderr
       end
+    end
 
-      context 'in default instance' do
-        it 'does not print anything' do
-          expect { printer.debug('FOO') }.not_to output.to_stderr
-        end
+    context 'in default instance' do
+      it 'does not print anything' do
+        expect { printer.debug('FOO') }.not_to output.to_stderr
       end
     end
   end

data/spec/ego/robot_error_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'ego/robot_error'
 
 RSpec.describe Ego::RobotError do

data/spec/ego/robot_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'ego/robot'
 
 RSpec.describe Ego::Robot do
@@ -5,10 +7,10 @@ RSpec.describe Ego::Robot do
   let(:options) { double('Ego::Options') }
   let(:plugin) { double('Ego::Plugin') }
   subject do
-    allow(options).to receive_messages({
+    allow(options).to receive_messages(
       robot_name: name,
-      verbose: false,
-    })
+      verbose: false
+    )
 
     described_class.new(options)
   end
@@ -97,7 +99,7 @@ RSpec.describe Ego::Robot do
       let(:priority) { 9 }
 
       before do
-        subject.on(condition, priority) { }
+        subject.on(condition, priority) {}
       end
 
       it 'passes the condition and action to a new handler' do
@@ -114,9 +116,9 @@ RSpec.describe Ego::Robot do
     context 'given a hash' do
       before do
         subject.on(
-          ->(q) { 'foo' } => 1,
-          ->(q) { 'bar' } => 2,
-        ) { }
+          ->(_q) { 'foo' } => 1,
+          ->(_q) { 'bar' } => 2
+        ) {}
       end
 
       it 'creates a new handler for each item' do
@@ -145,7 +147,7 @@ RSpec.describe Ego::Robot do
     end
 
     it 'executes the action in the context of the robot instance' do
-      expect(subject.run_action(->() { name }, [])).to eq(subject.name)
+      expect(subject.run_action(-> { name }, [])).to eq(subject.name)
     end
   end
 
@@ -161,12 +163,12 @@ RSpec.describe Ego::Robot do
 
     it 'is run by #run_action' do
       subject.before_action { print 'Before!' }
-      expect { subject.run_action(->(p) { true }, 'p') }.to output('Before!').to_stdout
+      expect { subject.run_action(->(_p) { true }, 'p') }.to output('Before!').to_stdout
     end
 
     it 'receives the action and action parameters' do
-      subject.before_action { |action, params| print params }
-      expect { subject.run_action(->(p) { true }, 'p') }.to output('p').to_stdout
+      subject.before_action { |_action, params| print params }
+      expect { subject.run_action(->(_p) { true }, 'p') }.to output('p').to_stdout
     end
   end
 
@@ -182,22 +184,22 @@ RSpec.describe Ego::Robot do
 
     it 'is run by #run_action' do
       subject.after_action { print 'After!' }
-      expect { subject.run_action(->(p) { 'out' }, 'p') }.to output('After!').to_stdout
+      expect { subject.run_action(->(_p) { 'out' }, 'p') }.to output('After!').to_stdout
     end
 
     it 'receives the action, parameters, and return value' do
-      subject.after_action { |action, params, result| print result + params }
-      expect { subject.run_action(->(p) { 'out' }, 'p') }.to output('outp').to_stdout
+      subject.after_action { |_action, params, result| print result + params }
+      expect { subject.run_action(->(_p) { 'out' }, 'p') }.to output('outp').to_stdout
     end
   end
 
   describe '#first_handler_for' do
     before do
       subject.on(
-        ->(q) { {} if 'bar'.match(q) } => 3,
-        ->(q) { {} if 'foo'.match(q) } => 2,
-        ->(q) { {} if 'foo'.match(q) } => 1,
-      ) { }
+        ->(q) { {} if /bar/ =~ q } => 3,
+        ->(q) { {} if /foo/ =~ q } => 2,
+        ->(q) { {} if /foo/ =~ q } => 1
+      ) {}
     end
 
     it 'chooses the highest-priority handler that matches the query' do
@@ -212,9 +214,9 @@ RSpec.describe Ego::Robot do
   describe '#handle' do
     before do
       subject.on(
-        ->(q) { {param: :three} if 'bar'.match(q) } => 3,
-        ->(q) { {param: :two} if 'foo'.match(q) } => 2,
-        ->(q) { {param: :one} if 'foo'.match(q) } => 1,
+        ->(q) { { param: :three } if /bar/ =~ q } => 3,
+        ->(q) { { param: :two } if /foo/ =~ q } => 2,
+        ->(q) { { param: :one } if /foo/ =~ q } => 1
       ) { |param| param }
     end
 
@@ -289,7 +291,7 @@ RSpec.describe Ego::Robot do
     end
 
     it 'is not run by #handle when the query is handled' do
-      subject.on('xxx') { }
+      subject.on('xxx') {}
       expect { subject.handle('xxx') }.not_to output('Oops!').to_stdout
     end