ego 0.1.0

data/README.md

@@ -0,0 +1,31 @@
+# Ego
+
+Ego is a personal command-line assistant that provides a flexible, natural
+language interface (sort of) for interacting with other programs. Think of
+it as a single-user IRC bot that can be extended with handlers for various
+natural-language queries.
+
+## Installation
+
+    $ gem install ego
+
+## Usage
+
+    $ ego what can you do?
+
+## License
+
+Copyright (C) 2016  Noah Frederick
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/ego

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require_relative '../lib/ego/runner'
+
+runner = Ego::Runner.new(ARGV)
+runner.run

data/ego.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ego/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ego"
+  spec.version       = Ego::VERSION
+  spec.authors       = ["Noah Frederick"]
+  spec.email         = ["acc.rubygems@noahfrederick.com"]
+  spec.summary       = %q{An extensible personal command-line assistant}
+  spec.description   = <<-EOF
+    Ego is a personal command-line assistant that provides a flexible, natural
+    language interface (sort of) for interacting with other programs. Think of
+    it as a single-user IRC bot that can be extended with handlers for various
+    natural-language queries.
+  EOF
+  spec.homepage      = "https://github.com/noahfrederick/ego"
+  spec.license       = "GPL-3.0+"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.4"
+  spec.add_development_dependency "guard-rspec"
+
+  spec.add_runtime_dependency "colorize", "~> 0.7"
+end

data/lib/ego.rb

@@ -0,0 +1,5 @@
+require "ego/version"
+
+module Ego
+  # Your code goes here...
+end

data/lib/ego/filesystem.rb

@@ -0,0 +1,31 @@
+module Ego::Filesystem
+  HANDLER_GLOB = 'handler/*.rb'
+
+  BASENAME = 'ego'
+
+  XDG_CACHE_HOME = ENV['XDG_CACHE_HOME'] || File.expand_path('~/.cache')
+  XDG_CONFIG_HOME = ENV['XDG_CONFIG_HOME'] || File.expand_path('~/.config')
+  XDG_DATA_HOME = ENV['XDG_DATA_HOME'] || File.expand_path('~/.local/share')
+
+  module_function
+
+  def cache path = ''
+    File.join XDG_CACHE_HOME, BASENAME, path
+  end
+
+  def config path = ''
+    File.join XDG_CONFIG_HOME, BASENAME, path
+  end
+
+  def data path = ''
+    File.join XDG_DATA_HOME, BASENAME, path
+  end
+
+  def builtin_handlers
+    Dir[File.expand_path(HANDLER_GLOB, __dir__)]
+  end
+
+  def user_handlers
+    Dir[File.expand_path(HANDLER_GLOB, config)]
+  end
+end

data/lib/ego/formatter.rb

@@ -0,0 +1,31 @@
+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
+      STDOUT.puts message.yellow
+    end
+
+    def robot_action message
+      STDOUT.puts "*#{message}*".magenta
+    end
+
+    def debug message
+      STDERR.puts message
+    end
+
+    def self.print_handlers handlers
+      handlers.keys.sort.each do |key|
+        STDOUT.puts "- #{handlers[key]}"
+      end
+    end
+  end
+end

data/lib/ego/handler.rb

@@ -0,0 +1,76 @@
+require_relative 'listener'
+require_relative 'formatter'
+
+module Ego
+  class Handler
+    @@handlers = {}
+    @@listeners = []
+
+    attr_reader :name
+    attr_accessor :description
+
+    def initialize name
+      @name = name
+    end
+
+    def to_s
+      "#{@description}"
+    end
+
+    def listen pattern, priority: 5, &parser
+      unless block_given?
+        parser = Proc.new { |matches| matches }
+      end
+      @@listeners << Ego::Listener.new(pattern, priority, parser, @name)
+    end
+
+    def run robot = nil, params = nil, &action
+      if block_given?
+        @action = action
+      end
+
+      if robot.nil?
+        return
+      elsif @action.arity == 1
+        @action.call(robot)
+      else
+        @action.call(robot, params)
+      end
+    end
+
+    def self.register name: nil
+      if name.nil?
+        handler_path = caller_locations(1, 1)[0].absolute_path
+        name = File.basename(handler_path, '.*')
+      end
+
+      handler = Ego::Handler.new(name)
+      yield handler
+
+      @@handlers[handler.name] = handler
+    end
+
+    def self.has handler_name
+      @@handlers.has_key? handler_name
+    end
+
+    def self.load handler_names
+      handler_names.each do |path|
+        handler = File.basename(path, '.*')
+        require path unless has(handler)
+      end
+    end
+
+    def self.dispatch robot, query
+      @@listeners.sort.reverse_each do |listener|
+        if params = listener.match(query)
+          return @@handlers[listener.handler].run(robot, params)
+        end
+      end
+    end
+
+    def self.handlers
+      @@handlers
+    end
+  end
+end

data/lib/ego/handler/default.rb

@@ -0,0 +1,15 @@
+Ego::Handler.register do |handler|
+  handler.description = 'let you know when I don\'t understand something'
+
+  handler.listen /(.*)/, priority: 0
+
+  handler.run do |robot, params|
+    robot.respond %Q{I don't understand "#{params[0]}".}
+
+    STDERR.puts <<-EOF
+Perhaps add a handler to #{Ego::Filesystem.config 'handler/{}.rb'}:
+
+...
+    EOF
+  end
+end

data/lib/ego/handler/echo.rb

@@ -0,0 +1,10 @@
+Ego::Handler.register do |handler|
+  handler.description = 'repeat what you say'
+
+  handler.listen /^(?:say|echo)\s+(?<input>.+)/i, priority: 6
+
+  handler.run do |robot, params|
+    robot.debug params
+    # robot.respond params[:input]
+  end
+end

data/lib/ego/handler/greet.rb

@@ -0,0 +1,17 @@
+Ego::Handler.register do |handler|
+  handler.description = 'greet you'
+
+  handler.listen /^(hello|salve|ave|hi|hey|ciao|hej)/i, priority: 3
+
+  handler.run do |robot|
+    robot.respond [
+      'Hello.',
+      'Salve tu.',
+      'Ave.',
+      'Hi.',
+      'Hey.',
+      'Ciao.',
+      'Hej.',
+    ].sample
+  end
+end

data/lib/ego/handler/handlers.rb

@@ -0,0 +1,14 @@
+require_relative '../handler'
+
+Ego::Handler.register do |handler|
+  handler.description = 'tell you what I can do'
+
+  handler.listen /^(show me|show|tell me|list)\s+(handlers|what you can do|what (?:you are|you're) able to do|what you do|what (?:queries )?you (?:can )?understand)$/i
+  handler.listen /^what (?:can you|are you able to|do you) (?:do|handle|understand)\??$/i
+
+  handler.run do |robot|
+    robot.respond 'I know how to...'
+
+    Ego::Formatter.print_handlers Ego::Handler.handlers
+  end
+end

data/lib/ego/handler/self.rb

@@ -0,0 +1,9 @@
+Ego::Handler.register do |handler|
+  handler.description = 'tell you who I am'
+
+  handler.listen /^(who are you|what('?s| is) your name)/i
+
+  handler.run do |robot|
+    robot.respond ["#{robot.name} sum.", "This is #{robot.name}, a robot."].sample
+  end
+end

data/lib/ego/listener.rb

@@ -0,0 +1,24 @@
+module Ego
+  class Listener
+    include Comparable
+
+    attr_accessor :pattern, :priority, :parser, :handler
+
+    def initialize pattern, priority, parser, handler
+      @pattern = pattern
+      @priority = priority
+      @parser = parser
+      @handler = handler
+    end
+
+    def <=> other
+      @priority <=> other.priority
+    end
+
+    def match query
+      return false unless matches = @pattern.match(query)
+
+      @parser.call matches
+    end
+  end
+end

data/lib/ego/options.rb

@@ -0,0 +1,52 @@
+require 'optparse'
+
+module Ego
+  class Options
+
+    attr_reader :mode,
+                :robot_name,
+                :verbose,
+                :query,
+                :usage,
+                :usage_error
+
+    def initialize(argv)
+      @mode = :interpret
+      @verbose = false
+      parse(argv)
+      @query = argv.join(" ")
+    end
+
+  private
+
+    def parse(argv)
+      OptionParser.new do |opts|
+        @robot_name = opts.program_name.capitalize
+        opts.banner = "Usage: #{opts.program_name} [ options ] query..."
+
+        opts.on("-v", "--version", "Print version number") do
+          @mode = :version
+        end
+
+        opts.on("-V", "--verbose", "Include debugging info in output") do
+          @verbose = true
+        end
+
+        opts.on("-h", "--help", "Show this message") do
+          @mode = :help
+        end
+
+        begin
+          argv = ["-h"] if argv.empty?
+          opts.parse!(argv)
+        rescue OptionParser::ParseError => e
+          @usage_error = e.message
+          @mode = :help
+        ensure
+          @usage = opts
+        end
+      end
+    end
+
+  end
+end

data/lib/ego/robot.rb

@@ -0,0 +1,35 @@
+module Ego
+  class Robot
+    attr_reader :name, :options
+
+    def initialize options, formatter
+      @name = options.robot_name
+      @options = options
+      @formatter = formatter
+    end
+
+    def respond message
+      @formatter.robot_respond message
+      true
+    end
+
+    def it message
+      @formatter.robot_action message
+      true
+    end
+
+    def debug message
+      return unless @options.verbose
+      @formatter.debug message
+      true
+    end
+
+    def stop
+      true
+    end
+
+    def continue
+      false
+    end
+  end
+end

data/lib/ego/runner.rb

@@ -0,0 +1,42 @@
+require_relative 'version'
+require_relative 'options'
+require_relative 'filesystem'
+require_relative 'robot'
+require_relative 'handler'
+
+module Ego
+  # The Ego::Runner class, given an array of arguments, initializes the
+  # required objects and executes the request.
+  class Runner
+    # Takes an array of arguments and parses them into options:
+    #
+    #   runner = Ego::Runner.new(ARGV)
+    #
+    def initialize(argv)
+      @options = Options.new(argv)
+      @formatter = Ego::Formatter.new
+    end
+
+    # Run the appropriate action based on the arguments provided to
+    # #initialize.
+    def run
+      case @options.mode
+      when :help
+        if @options.usage_error
+          STDERR.puts @options.usage_error, "\n"
+        end
+
+        @formatter.puts @options.usage
+
+        exit(-1) if @options.usage_error
+      when :version
+        @formatter.puts "ego v#{Ego::VERSION}"
+      else
+        robot = Ego::Robot.new(@options, @formatter)
+        Ego::Handler.load Ego::Filesystem.user_handlers
+        Ego::Handler.load Ego::Filesystem.builtin_handlers
+        Ego::Handler.dispatch robot, @options.query
+      end
+    end
+  end
+end