ego 0.3.0 → 0.4.0

data/spec/ego/robot_error_spec.rb

@@ -0,0 +1,12 @@
+require 'ego/robot_error'
+
+RSpec.describe Ego::RobotError do
+  let(:msg) { 'error message' }
+  subject { described_class.new(msg) }
+
+  describe '#message' do
+    it 'returns the error message' do
+      expect(subject.message).to eq(msg)
+    end
+  end
+end

data/spec/ego/robot_spec.rb

@@ -1,43 +1,300 @@
 require 'ego/robot'
 
 RSpec.describe Ego::Robot do
-  it 'sets its name' do
-    formatter = double('Ego::Formatter')
-    options = double('Ego::Options')
-    allow(options).to receive(:verbose)
-    expect(options).to receive_messages(robot_name: 'foo')
+  let(:name) { 'TestBot' }
+  let(:options) { double('Ego::Options') }
+  let(:plugin) { double('Ego::Plugin') }
+  subject do
+    allow(options).to receive_messages({
+      robot_name: name,
+      verbose: false,
+    })
 
-    robot = Ego::Robot.new(options, formatter)
-    expect(robot.name).to eq('foo')
+    described_class.new(options)
   end
 
-  describe '#debug' do
-    context 'in non-verbose mode' do
-      before(:example) do
-        @options = double('Ego::Options')
-        allow(@options).to receive_messages(robot_name: 'foo', verbose: false)
-        @formatter = double('Ego::Formatter')
+  context 'on initization' do
+    it 'sets its name' do
+      expect(subject.name).to eq(name)
+    end
+
+    it 'exposes the passed options object' do
+      expect(subject.options).to be options
+    end
+
+    it 'has no capabilities' do
+      expect(subject.capabilities).to be_empty
+    end
+  end
+
+  describe '#on_ready' do
+    it 'is defined' do
+      expect(subject.respond_to?(:on_ready)).to be true
+    end
+
+    it 'can be hooked into' do
+      subject.on_ready { print 'Ready!' }
+      expect { subject.run_hook :on_ready }.to output('Ready!').to_stdout
+    end
+  end
+
+  describe '#on_shutdown' do
+    it 'is defined' do
+      expect(subject.respond_to?(:on_shutdown)).to be true
+    end
+
+    it 'can be hooked into' do
+      subject.on_shutdown { print 'Bye!' }
+      expect { subject.run_hook :on_shutdown }.to output('Bye!').to_stdout
+    end
+  end
+
+  describe '#ready' do
+    it 'runs the on_ready hook' do
+      subject.on_ready { print 'Ready!' }
+      expect { subject.ready }.to output('Ready!').to_stdout
+    end
+
+    it 'is chainable' do
+      expect(subject.ready).to be subject
+    end
+  end
+
+  describe '#shutdown' do
+    it 'runs the on_shutdown hook' do
+      subject.on_shutdown { print 'Bye!' }
+      expect { subject.shutdown }.to output('Bye!').to_stdout
+    end
+  end
+
+  describe '#provide' do
+    it 'is an alias for #define_singleton_method' do
+      expect(subject.respond_to?(:foo)).to be false
+      subject.provide(:foo) { :bar }
+      expect(subject.respond_to?(:foo)).to be true
+      expect(subject.foo).to eq(:bar)
+    end
+  end
+
+  describe '#can' do
+    context 'without a plug-in context set' do
+      it 'fails' do
+        expect { subject.can('fail') }.to raise_error(Ego::RobotError)
+      end
+    end
+
+    context 'with a plug-in context set' do
+      let(:plugin_name) { 'my_plug' }
+      before do
+        allow(plugin).to receive(:name) { plugin_name }
+        subject.context = plugin
+      end
+
+      it 'adds a capability' do
+        expect(subject.capabilities).to be_empty
+        subject.can('succeed')
+        expect(subject.capabilities).not_to be_empty
+      end
+
+      it 'sets the capability description' do
+        subject.can('succeed')
+        expect(subject.capabilities.last.desc).to eq('succeed')
+      end
+
+      it 'records the plug-in with the capability' do
+        subject.can('succeed')
+        expect(subject.capabilities.last.plugin.name).to eq(plugin_name)
+      end
+    end
+  end
+
+  describe '#on' do
+    context 'given a single condition' do
+      let(:condition) { /^some condition/i }
+      let(:priority) { 9 }
+
+      before do
+        subject.on(condition, priority) { }
       end
 
-      it 'does nothing' do
-        expect(@formatter).not_to receive(:debug)
-        robot = Ego::Robot.new(@options, @formatter)
-        robot.debug 'foo'
+      it 'passes the condition and action to a new handler' do
+        expect(subject.instance_variable_get(:@handlers).count).to eq(1)
+        expect(subject.instance_variable_get(:@handlers).last).to be_instance_of(Ego::Handler)
+      end
+
+      it 'passes the condition and action to a new handler with a priority' do
+        expect(subject.instance_variable_get(:@handlers).count).to eq(1)
+        expect(subject.instance_variable_get(:@handlers).last.priority).to eq(priority)
       end
     end
 
-    context 'in verbose mode' do
-      before(:example) do
-        @options = double('Ego::Options')
-        allow(@options).to receive_messages(robot_name: 'foo', verbose: true)
-        @formatter = double('Ego::Formatter')
+    context 'given a hash' do
+      before do
+        subject.on(
+          ->(q) { 'foo' } => 1,
+          ->(q) { 'bar' } => 2,
+        ) { }
+      end
+
+      it 'creates a new handler for each item' do
+        expect(subject.instance_variable_get(:@handlers).count).to eq(2)
+      end
+
+      it 'uses the keys as conditions' do
+        expect(subject.instance_variable_get(:@handlers).first.condition.call('')).to eq('foo')
+      end
+
+      it 'uses the values as priorities' do
+        expect(subject.instance_variable_get(:@handlers).first.priority).to eq(1)
       end
+    end
 
-      it 'passes the message to the formatter' do
-        expect(@formatter).to receive(:debug).with('foo')
-        robot = Ego::Robot.new(@options, @formatter)
-        robot.debug 'foo'
+    context 'given no action block' do
+      it 'raises an error' do
+        expect { subject.on(:foo) }.to raise_error(Ego::RobotError)
       end
     end
   end
+
+  describe '#run_action' do
+    it 'calls the action with supplied parameters' do
+      expect(subject.run_action(->(params) { params }, 'foo')).to eq('foo')
+    end
+
+    it 'executes the action in the context of the robot instance' do
+      expect(subject.run_action(->(params) { name }, 'foo')).to eq(subject.name)
+    end
+  end
+
+  describe '#before_action' do
+    it 'is defined' do
+      expect(subject.respond_to?(:before_action)).to be true
+    end
+
+    it 'can be hooked into' do
+      subject.before_action { print 'Before!' }
+      expect { subject.run_hook :before_action }.to output('Before!').to_stdout
+    end
+
+    it 'is run by #run_action' do
+      subject.before_action { print 'Before!' }
+      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
+    end
+  end
+
+  describe '#after_action' do
+    it 'is defined' do
+      expect(subject.respond_to?(:after_action)).to be true
+    end
+
+    it 'can be hooked into' do
+      subject.after_action { print 'After!' }
+      expect { subject.run_hook :after_action }.to output('After!').to_stdout
+    end
+
+    it 'is run by #run_action' do
+      subject.after_action { print 'After!' }
+      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
+    end
+  end
+
+  describe '#handle' do
+    before do
+      subject.on(
+        ->(q) { :three if 'bar'.match(q) } => 3,
+        ->(q) { :two if 'foo'.match(q) } => 2,
+        ->(q) { :one if 'foo'.match(q) } => 1,
+      ) { |params| params }
+    end
+
+    it 'chooses the highest-priority handler that matches the query' do
+      expect(subject.handle('foo')).to eq(:two)
+    end
+
+    it 'returns false when no handlers match' do
+      expect(subject.handle('xxx')).to be false
+    end
+  end
+
+  describe '#before_handle_query' do
+    it 'is defined' do
+      expect(subject.respond_to?(:before_handle_query)).to be true
+    end
+
+    it 'can be hooked into' do
+      subject.before_handle_query { print 'Before!' }
+      expect { subject.run_hook :before_handle_query }.to output('Before!').to_stdout
+    end
+
+    it 'is run by #handle' do
+      subject.before_handle_query { print 'Before!' }
+      expect { subject.handle('xxx') }.to output('Before!').to_stdout
+    end
+
+    it 'receives the query' do
+      subject.before_handle_query { |query| print query }
+      expect { subject.handle('xxx') }.to output('xxx').to_stdout
+    end
+  end
+
+  describe '#after_handle_query' do
+    it 'is defined' do
+      expect(subject.respond_to?(:after_handle_query)).to be true
+    end
+
+    it 'can be hooked into' do
+      subject.after_handle_query { print 'After!' }
+      expect { subject.run_hook :after_handle_query }.to output('After!').to_stdout
+    end
+
+    it 'is run by #handle' do
+      subject.on('xxx') { true }
+      subject.after_handle_query { print 'After!' }
+      expect { subject.handle('xxx') }.to output('After!').to_stdout
+    end
+
+    it 'receives the query and handler' do
+      subject.on('xxx') { true }
+      subject.after_handle_query { |query, handler| print query unless handler.nil? }
+      expect { subject.handle('xxx') }.to output('xxx').to_stdout
+    end
+  end
+
+  describe '#on_unhandled_query' do
+    before do
+      subject.on_unhandled_query { print 'Oops!' }
+    end
+
+    it 'is defined' do
+      expect(subject.respond_to?(:on_unhandled_query)).to be true
+    end
+
+    it 'can be hooked into' do
+      expect { subject.run_hook :on_unhandled_query }.to output('Oops!').to_stdout
+    end
+
+    it 'is run by #handle when no handlers match' do
+      expect { subject.handle('xxx') }.to output('Oops!').to_stdout
+    end
+
+    it 'is not run by #handle when the query is handled' do
+      subject.on('xxx') { }
+      expect { subject.handle('xxx') }.not_to output('Oops!').to_stdout
+    end
+
+    it 'receives the query' do
+      subject.on_unhandled_query { |query| print query }
+      expect { subject.handle('xxx') }.to output('Oops!xxx').to_stdout
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ego
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Noah Frederick
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: hooks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
 description: |2
       Ego is a personal command-line assistant that provides a flexible, natural
       language interface (sort of) for interacting with other programs. Think of
@@ -94,6 +108,8 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".travis.yml"
+- ".yardopts"
 - Gemfile
 - Guardfile
 - LICENSE.txt
@@ -102,21 +118,27 @@ files:
 - bin/ego
 - ego.gemspec
 - lib/ego.rb
+- lib/ego/capability.rb
 - lib/ego/filesystem.rb
-- lib/ego/formatter.rb
 - lib/ego/handler.rb
-- lib/ego/handler/default.rb
-- lib/ego/handler/echo.rb
-- lib/ego/handler/greet.rb
-- lib/ego/handler/handlers.rb
-- lib/ego/handler/self.rb
-- lib/ego/listener.rb
 - lib/ego/options.rb
+- lib/ego/plugin.rb
+- lib/ego/plugins/capabilities.rb
+- lib/ego/plugins/fallback.rb
+- lib/ego/plugins/robot_io.rb
+- lib/ego/plugins/social.rb
+- lib/ego/plugins/system.rb
+- lib/ego/printer.rb
 - lib/ego/robot.rb
+- lib/ego/robot_error.rb
 - lib/ego/runner.rb
 - lib/ego/version.rb
-- spec/ego/formatter_spec.rb
+- spec/ego/capability_spec.rb
+- spec/ego/handler_spec.rb
 - spec/ego/options_spec.rb
+- spec/ego/plugin_spec.rb
+- spec/ego/printer_spec.rb
+- spec/ego/robot_error_spec.rb
 - spec/ego/robot_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/noahfrederick/ego
@@ -144,7 +166,11 @@ signing_key:
 specification_version: 4
 summary: An extensible personal command-line assistant
 test_files:
-- spec/ego/formatter_spec.rb
+- spec/ego/capability_spec.rb
+- spec/ego/handler_spec.rb
 - spec/ego/options_spec.rb
+- spec/ego/plugin_spec.rb
+- spec/ego/printer_spec.rb
+- spec/ego/robot_error_spec.rb
 - spec/ego/robot_spec.rb
 - spec/spec_helper.rb

data/lib/ego/formatter.rb

@@ -1,36 +0,0 @@
-require 'colorize'
-
-module Ego
-  class Formatter
-    def initialize
-      String.disable_colorization = !$stdout.isatty
-    end
-
-    def puts(message)
-      $stdout.puts message
-    end
-
-    def robot_respond(message, *replacements)
-      message = sprintf(message, *replacements)
-      message = message[0].upcase + message[1..-1]
-
-      $stdout.puts message.yellow
-    end
-
-    def robot_action(message)
-      $stdout.puts "*#{message}*".magenta
-    end
-
-    def debug(message, *replacements)
-      message = sprintf(message, *replacements)
-
-      $stderr.puts message
-    end
-
-    def self.print_handlers(handlers)
-      handlers.keys.sort.each do |key|
-        $stdout.puts "- #{handlers[key]}"
-      end
-    end
-  end
-end