ego 0.3.0 → 0.4.0

data/lib/ego/robot_error.rb

@@ -0,0 +1,8 @@
+module Ego
+  # Error type raised by robot plug-in DSL.
+  #
+  # `RobotError`s print their message to STDERR and halt execution of the
+  # program.
+  class RobotError < RuntimeError
+  end
+end

data/lib/ego/runner.rb

@@ -1,73 +1,104 @@
 require_relative '../ego'
+require_relative 'options'
 
 module Ego
-  # The Ego::Runner class, given an array of arguments, initializes the
-  # required objects and executes the request.
+  # The Runner class, given an array of arguments, initializes the required
+  # objects and executes the request.
   class Runner
+    # Prompt to display in shell-mode
     PROMPT = 'ego, '.green.freeze
+    # Pattern that triggers shell-mode to exit
     QUIT = /^q(uit)?|exit|(good)?bye$/.freeze
 
     # Takes an array of arguments and parses them into options:
     #
+    # @example
     #   runner = Ego::Runner.new(ARGV)
     #
+    # @param argv [Array] command-line arguments
     def initialize(argv)
       @options = Options.new(argv)
-      @formatter = Ego::Formatter.new
     end
 
     # Run the appropriate action based on the arguments provided to
-    # #initialize.
+    # `#initialize`.
+    #
+    # @return [void]
     def run
       case @options.mode
       when :help
         if @options.usage_error
-          STDERR.puts @options.usage_error, "\n"
+          Printer.errs @options.usage_error, "\n"
         end
 
-        @formatter.puts @options.usage
+        Printer.puts @options.usage
 
         exit(-1) if @options.usage_error
       when :version
-        @formatter.puts "ego v#{Ego::VERSION}"
+        Printer.puts "ego v#{Ego::VERSION}"
       when :shell
-        init_robot
-        start_repl
+        start_shell(robot_factory)
       else
-        init_robot
-        handle_query @options.query
+        handle_query(robot_factory, @options.query)
       end
+    rescue RobotError => e
+      Printer.errs e.message
+      exit(-2)
     end
 
     protected
 
-    def init_robot
-      @robot = Ego::Robot.new(@options, @formatter)
-      Ego::Handler.load Ego::Filesystem.user_handlers
-      Ego::Handler.load Ego::Filesystem.builtin_handlers
+    # Get a robot and enhance it with plug-ins.
+    #
+    # @return [Robot] a decorated robot instance
+    def robot_factory
+      Plugin.load Filesystem.builtin_plugins
+
+      if @options.plugins
+        Plugin.load Filesystem.user_plugins
+      end
+
+      Plugin.decorate(Robot.new(@options)).ready
     end
 
-    def handle_query(query)
-      Ego::Handler.dispatch @robot, query
+    # Handle and single query and shut down.
+    #
+    # @param robot [Robot] the robot to handle the query
+    # @param query [String] the query to handle
+    # @return [void]
+    def handle_query(robot, query)
+      robot.handle(query)
+    ensure
+      robot.shutdown
     end
 
+    # Show a prompt and read input from the user.
+    #
+    # @return [String, nil] the user query
     def prompt
       Readline.readline(PROMPT, true)
     end
 
-    def start_repl
+    # Start a REPL for handling multiple queries in one session.
+    #
+    # @param robot [Robot] the robot to handle the query
+    # @return [void]
+    def start_shell(robot)
       require 'readline'
 
-      # Store the state of the terminal
+      # Save the state of the terminal
       stty_save = `stty -g`.chomp
 
       loop do
         query = prompt
         break if query.nil? || query.strip =~ QUIT
-        handle_query query.strip
+        robot.handle(query.strip)
       end
     rescue Interrupt => e
       system('stty', stty_save) # Restore state
+      robot.say e.message
+    ensure
+      robot.shutdown
     end
   end
 end

data/lib/ego/version.rb

@@ -1,3 +1,4 @@
 module Ego
-  VERSION = '0.3.0'
+  # Gem version
+  VERSION = '0.4.0'
 end

data/spec/ego/capability_spec.rb

@@ -0,0 +1,23 @@
+require 'ego/capability'
+
+RSpec.describe Ego::Capability do
+  let(:desc) { 'my desc' }
+  let(:plugin) { double('Ego::Plugin') }
+  subject { described_class.new(desc, plugin) }
+
+  context 'on initization' do
+    it 'sets its description' do
+      expect(subject.desc).to eq(desc)
+    end
+
+    it 'sets its plug-in' do
+      expect(subject.plugin).to be plugin
+    end
+  end
+
+  describe '#to_s' do
+    it 'returns the description' do
+      expect(subject.to_s).to eq(desc)
+    end
+  end
+end

data/spec/ego/handler_spec.rb

@@ -0,0 +1,63 @@
+require 'ego/handler'
+
+RSpec.describe Ego::Handler do
+  let(:condition) { ->(q) { 'bar' if q == 'foo' } }
+  let(:regexp) { /^baz/i }
+  let(:action) { ->(p) { puts p } }
+  let(:priority) { 2 }
+  subject { described_class.new(condition, action, priority) }
+
+  context 'on initization' do
+    it 'sets its condition' do
+      expect(subject.condition).to be condition
+    end
+
+    it 'sets its action' do
+      expect(subject.action).to be action
+    end
+
+    it 'sets its priority' do
+      expect(subject.priority).to be priority
+    end
+
+    it 'defaults its priority to 5' do
+      default_handler = described_class.new(condition, action)
+      expect(default_handler.priority).to eq(5)
+    end
+
+    describe 'given something matchable as the condition' do
+      it 'encloses it' do
+        expect(regexp.respond_to?(:match)).to be true
+        expect(regexp.respond_to?(:call)).to be false
+        regexp_handler = described_class.new(regexp, action, priority)
+        expect(regexp_handler.condition.respond_to?(:match)).to be false
+        expect(regexp_handler.condition.respond_to?(:call)).to be true
+      end
+    end
+  end
+
+  it 'is comparable' do
+    expect(subject.respond_to?(:'<=>')).to be true
+  end
+
+  it 'compares priorities' do
+    handler1 = described_class.new(condition, action, 1)
+    handler2 = described_class.new(condition, action, 2)
+    expect(handler2).to be > handler1
+    expect(handler1).to be < handler2
+  end
+
+  describe '#handle' do
+    context 'when the query cannot be handled' do
+      it 'returns false' do
+        expect(subject.handle('fail')).to be false
+      end
+    end
+
+    context 'when the query can be handled' do
+      it 'returns the result of the condition closure' do
+        expect(subject.handle('foo')).to eq('bar')
+      end
+    end
+  end
+end

data/spec/ego/options_spec.rb

@@ -2,68 +2,78 @@ require 'ego/options'
 
 RSpec.describe Ego::Options do
   it 'defaults to interpret-mode' do
-    opts = Ego::Options.new(['foo'])
+    opts = described_class.new(['foo'])
     expect(opts.mode).to eq(:interpret)
   end
 
   it 'can be set to shell-mode' do
-    opts = Ego::Options.new(['-s'])
+    opts = described_class.new(['-s'])
     expect(opts.mode).to eq(:shell)
   end
 
   it 'can be set to version-mode' do
-    opts = Ego::Options.new(['-v'])
+    opts = described_class.new(['-v'])
     expect(opts.mode).to eq(:version)
   end
 
   it 'can be set to help-mode' do
-    opts = Ego::Options.new(['-h'])
+    opts = described_class.new(['-h'])
     expect(opts.mode).to eq(:help)
   end
 
   it 'defaults to help-mode with no arguments' do
-    opts = Ego::Options.new([])
+    opts = described_class.new([])
     expect(opts.mode).to eq(:help)
   end
 
+  it 'defaults to loading user plug-ins' do
+    opts = described_class.new(['foo'])
+    expect(opts.plugins).to be true
+  end
+
+  it 'can be set to not load user plug-ins' do
+    opts = described_class.new(['-n', 'foo'])
+    expect(opts.plugins).to be false
+  end
+
   it 'defaults to not verbose' do
-    opts = Ego::Options.new(['foo'])
+    opts = described_class.new(['foo'])
     expect(opts.verbose).to be false
   end
 
   it 'can be set to verbose' do
-    opts = Ego::Options.new(['-V', 'foo'])
+    opts = described_class.new(['-V', 'foo'])
     expect(opts.verbose).to be true
   end
 
   it 'sets the query to remaining args join with spaces' do
-    opts = Ego::Options.new(['foo', 'bar'])
+    opts = described_class.new(['foo', 'bar'])
     expect(opts.query).to eq('foo bar')
   end
 
   it 'sets the robot name' do
-    opts = Ego::Options.new(['foo'])
+    opts = described_class.new(['foo'])
     expect(opts.robot_name).to_not be_nil
   end
 
   it 'sets the usage' do
-    opts = Ego::Options.new(['foo'])
+    opts = described_class.new(['foo'])
     expect(opts.usage).to be_instance_of OptionParser
   end
 
   it 'does not set a usage error normally' do
-    opts = Ego::Options.new(['foo'])
+    opts = described_class.new(['foo'])
     expect(opts.usage_error).to be_nil
   end
 
   context 'with invalid option' do
     it 'sets a usage error message' do
-      opts = Ego::Options.new(['--does-not-exist'])
+      opts = described_class.new(['--does-not-exist'])
       expect(opts.usage_error).to eq('invalid option: --does-not-exist')
     end
 
     it 'sets help-mode' do
-      opts = Ego::Options.new(['--does-not-exist'])
+      opts = described_class.new(['--does-not-exist'])
       expect(opts.mode).to eq(:help)
     end
   end

data/spec/ego/plugin_spec.rb

@@ -0,0 +1,68 @@
+require 'ego/plugin'
+
+RSpec.describe Ego::Plugin do
+  let(:name) { 'my_plug' }
+  let(:body) { proc { true } }
+  let(:plugin) { described_class.new(name, body) }
+  let(:builtin_plugin) { described_class.new(name, body, builtin: true) }
+
+  context 'on initization' do
+    it 'sets its name' do
+      expect(plugin.name).to eq(name)
+    end
+
+    it 'sets its body' do
+      expect(plugin.body).to be body
+    end
+
+    it 'sets its builtin flag' do
+      expect(builtin_plugin.builtin).to be true
+    end
+
+    it 'defaults its builtin flag to false' do
+      expect(plugin.builtin).to be false
+    end
+  end
+
+  describe '.register' do
+    it 'returns a new plugin' do
+      expect(described_class.register(name, body)).to be_instance_of(described_class)
+    end
+  end
+
+
+  describe '.decorate' do
+    let(:obj) do
+      Class.new { attr_accessor :context, :a, :b }.new
+    end
+
+    before do
+      described_class.class_variable_set :@@plugins, {}
+      described_class.register('a', proc { |obj|
+        obj.a = 'foo'
+      })
+      described_class.register('b', proc { |obj|
+        obj.b = 'bar'
+      })
+    end
+
+    it 'sets obj#context to each registered plugin' do
+      expect(obj).to receive(:context=).twice
+      described_class.decorate(obj)
+    end
+
+    it 'calls each plugin body passing the obj' do
+      expect(obj).to receive_messages({
+        :a= => 'foo',
+        :b= => 'bar',
+      })
+      described_class.decorate(obj)
+    end
+
+    it 'returns the decorated obj' do
+      decorated = described_class.decorate(obj)
+      expect(decorated.a).to eq('foo')
+      expect(decorated.b).to eq('bar')
+    end
+  end
+end

data/spec/ego/printer_spec.rb

@@ -0,0 +1,120 @@
+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 }
+
+    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 '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
+    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 '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
+    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 '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
+    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 '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
+
+      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 '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
+
+      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
+
+        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
+      end
+    end
+  end
+end