ruboty 1.0.0

data/lib/ruboty/handlers/base.rb

@@ -0,0 +1,37 @@
+module Ruboty
+  module Handlers
+    class Base
+      class << self
+        include Mem
+
+        def inherited(child)
+          Ruboty.handlers << child
+        end
+
+        def on(pattern, options = {})
+          actions << Action.new(pattern, options)
+        end
+
+        def actions
+          []
+        end
+        memoize :actions
+      end
+
+      include Env::Validatable
+
+      attr_reader :robot
+
+      def initialize(robot)
+        @robot = robot
+        validate!
+      end
+
+      def call(message)
+        self.class.actions.each do |action|
+          action.call(self, message)
+        end
+      end
+    end
+  end
+end

data/lib/ruboty/handlers/help.rb

@@ -0,0 +1,11 @@
+module Ruboty
+  module Handlers
+    class Help < Base
+      on /help( me)?\z/i, name: "help", description: "Show this help message"
+
+      def help(message)
+        Ruboty::Actions::Help.new(message).call
+      end
+    end
+  end
+end

data/lib/ruboty/handlers/ping.rb

@@ -0,0 +1,11 @@
+module Ruboty
+  module Handlers
+    class Ping < Base
+      on /ping\z/i, name: "ping", description: "Return PONG to PING"
+
+      def ping(message)
+        Ruboty::Actions::Ping.new(message).call
+      end
+    end
+  end
+end

data/lib/ruboty/handlers/whoami.rb

@@ -0,0 +1,15 @@
+module Ruboty
+  module Handlers
+    class Whoami < Base
+      on(
+        /who am i\?/i,
+        name: "whoami",
+        description: "Answer who you are",
+      )
+
+      def whoami(message)
+        Ruboty::Actions::Whoami.new(message).call
+      end
+    end
+  end
+end

data/lib/ruboty/logger.rb

@@ -0,0 +1,10 @@
+require "logger"
+
+module Ruboty
+  class Logger < Logger
+    def initialize(*)
+      super
+      @formatter = ->(severity, time, name, message) { "#{message}\n" }
+    end
+  end
+end

data/lib/ruboty/message.rb

@@ -0,0 +1,47 @@
+module Ruboty
+  class Message
+    attr_reader(
+      :match_data,
+      :original,
+    )
+
+    def initialize(original)
+      @original = original
+    end
+
+    def body
+      @original[:body]
+    end
+
+    def from
+      @original[:from]
+    end
+
+    # @note Some chat service such as XMPP has 2 types of address, address and username
+    # @return [String] User identifier in the Chat service
+    def from_name
+      @original[:from_name] || from
+    end
+
+    def robot
+      @original[:robot]
+    end
+
+    def to
+      @original[:to]
+    end
+
+    def match(pattern)
+      @match_data = pattern.match(body)
+    end
+
+    def [](index)
+      match_data[index]
+    end
+
+    def reply(body, options = {})
+      attributes = { body: body, from: to, to: from, original: original }.merge(options)
+      robot.say(attributes)
+    end
+  end
+end

data/lib/ruboty/robot.rb

@@ -0,0 +1,76 @@
+module Ruboty
+  class Robot
+    DEFAULT_ROBOT_NAME = "ruboty"
+
+    include Mem
+
+    delegate :say, to: :adapter
+
+    attr_reader :options
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def run
+      dotenv
+      bundle
+      setup
+      remember
+      handle
+      adapt
+    end
+
+    def receive(attributes)
+      message = Message.new(attributes.merge(robot: self))
+      handlers.each do |handler|
+        handler.call(message)
+      end
+    end
+
+    def name
+      ENV["ROBOT_NAME"] || DEFAULT_ROBOT_NAME
+    end
+
+    def brain
+      Brains::Base.find_class.new
+    end
+    memoize :brain
+
+    private
+
+    def adapt
+      adapter.run
+    end
+
+    def adapter
+      AdapterBuilder.new(self).build
+    end
+    memoize :adapter
+
+    def bundle
+      Bundler.require
+    end
+
+    def dotenv
+      Dotenv.load if options[:dotenv]
+    end
+
+    def setup
+      load(options[:load]) if options[:load]
+    end
+
+    def handlers
+      Ruboty.handlers.map {|handler_class| handler_class.new(self) }
+    end
+    memoize :handlers
+
+    def remember
+      brain
+    end
+
+    def handle
+      handlers
+    end
+  end
+end

data/lib/ruboty/version.rb

@@ -0,0 +1,3 @@
+module Ruboty
+  VERSION = "1.0.0"
+end

data/lib/ruboty.rb

@@ -0,0 +1,58 @@
+require "active_support/concern"
+require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/string/inflections"
+require "bundler"
+require "dotenv"
+require "mem"
+require "slop"
+
+module Ruboty
+  class << self
+    include Mem
+
+    def logger
+      @logger ||= Ruboty::Logger.new($stdout)
+    end
+
+    def die(message)
+      logger.error("Error: #{message}")
+      exit(1)
+    end
+
+    def handlers
+      []
+    end
+    memoize :handlers
+
+    def actions
+      handlers.map(&:actions).flatten.sort_by(&:all?)
+    end
+  end
+end
+
+require "ruboty/action"
+require "ruboty/actions/base"
+require "ruboty/actions/help"
+require "ruboty/actions/ping"
+require "ruboty/actions/whoami"
+require "ruboty/adapter_builder"
+require "ruboty/env"
+require "ruboty/env/missing_required_key_error"
+require "ruboty/env/validatable"
+require "ruboty/env/validation_error"
+require "ruboty/adapters/base"
+require "ruboty/adapters/shell"
+require "ruboty/brains/base"
+require "ruboty/brains/memory"
+require "ruboty/command_builder"
+require "ruboty/commands/base"
+require "ruboty/commands/generate"
+require "ruboty/commands/run"
+require "ruboty/handlers/base"
+require "ruboty/handlers/help"
+require "ruboty/handlers/ping"
+require "ruboty/handlers/whoami"
+require "ruboty/logger"
+require "ruboty/message"
+require "ruboty/robot"
+require "ruboty/version"

data/ruboty.gemspec

@@ -0,0 +1,29 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "ruboty/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruboty"
+  spec.version       = Ruboty::VERSION
+  spec.authors       = ["Ryo Nakamura"]
+  spec.email         = ["r7kamura@gmail.com"]
+  spec.summary       = "Ruby + Bot = Ruboty"
+  spec.homepage      = "https://github.com/r7kamura/ruboty"
+  spec.license       = "MIT"
+
+  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_dependency "activesupport"
+  spec.add_dependency "bundler"
+  spec.add_dependency "dotenv"
+  spec.add_dependency "mem"
+  spec.add_dependency "slop"
+  spec.add_development_dependency "codeclimate-test-reporter", ">= 0.3.0"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "2.14.1"
+  spec.add_development_dependency "simplecov"
+end

data/spec/ruboty/adapter_builder_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe Ruboty::AdapterBuilder do
+  let(:builder) do
+    described_class.new(robot)
+  end
+
+  let(:robot) do
+    Ruboty::Robot.new
+  end
+
+  describe "#build" do
+    context "with no other adapter class definition" do
+      it "returns a Ruboty::Adapters::Shell as a default adapter" do
+        builder.build.should be_a Ruboty::Adapters::Shell
+      end
+    end
+
+    context "with another adapter class definition" do
+      after do
+        Ruboty::AdapterBuilder.adapter_classes.pop
+      end
+
+      let!(:another_adapter_class) do
+        Class.new(Ruboty::Adapters::Base) do
+          def run
+          end
+        end
+      end
+
+      it "returns an instance of that adapter class" do
+        builder.build.should be_a another_adapter_class
+      end
+    end
+  end
+end

data/spec/ruboty/adapters/shell_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+describe Ruboty::Adapters::Shell do
+  before do
+    Ruboty.logger.stub(:info)
+  end
+
+  let(:adapter) do
+    described_class.new(robot)
+  end
+
+  let(:robot) do
+    Ruboty::Robot.new
+  end
+
+  describe "#run" do
+    context "with `exit`" do
+      it "stops" do
+        Readline.stub(readline: "exit")
+        adapter.should_receive(:stop).and_call_original
+        adapter.run
+      end
+    end
+
+    context "with `quit`" do
+      it "stops" do
+        Readline.stub(readline: "exit")
+        adapter.should_receive(:stop).and_call_original
+        adapter.run
+      end
+    end
+
+    context "with Inturrupt from console" do
+      it "stops" do
+        Readline.stub(:readline).and_raise(Interrupt)
+        adapter.should_receive(:stop).and_call_original
+        adapter.run
+      end
+    end
+
+    context "without `exit` nor `quit`" do
+      it "passes given message to robot" do
+        Readline.stub(:readline).and_return("a", "exit")
+        robot.should_receive(:receive).with(body: "a", source: described_class::SOURCE)
+        adapter.run
+      end
+    end
+  end
+
+  describe "#say" do
+    it "shows given message body on stdout" do
+      Ruboty.logger.should_receive(:info).with("a")
+      adapter.say(body: "a")
+    end
+  end
+end

data/spec/ruboty/commands/generate_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe Ruboty::Commands::Generate do
+  describe "#call" do
+    after do
+      FileUtils.rmtree("./ruboty/")
+    end
+
+    let(:command) do
+      Ruboty::CommandBuilder.new(arguments).build
+    end
+
+    let(:call) do
+      command.call
+    end
+
+    let(:arguments) do
+      ["--generate"]
+    end
+
+    context "with normal condition" do
+      it "generates ./ruboty/ directory from our templates" do
+        call
+        File.exists?("./ruboty/").should == true
+      end
+    end
+
+    context "when ./ruboty/ directory already exists" do
+      before do
+        FileUtils.mkdir("./ruboty/")
+      end
+
+      it "exits process with dying message" do
+        Ruboty.logger.should_receive(:error).with("Error: ./ruboty/ already exists.")
+        expect { call }.to raise_error(SystemExit)
+      end
+    end
+  end
+end

data/spec/ruboty/commands/run_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe Ruboty::Commands::Run do
+  describe "#call" do
+    let(:command) do
+      Ruboty::CommandBuilder.new(arguments).build
+    end
+
+    let(:call) do
+      command.call
+    end
+
+    let(:arguments) do
+      []
+    end
+
+    it "creates an adapter and calls .run to it" do
+      Ruboty::Adapters::Shell.any_instance.should_receive(:run)
+      call
+    end
+  end
+end

data/spec/ruboty/env/validatable_spec.rb

@@ -0,0 +1,48 @@
+require "spec_helper"
+
+describe Ruboty::Env::Validatable do
+  let(:validatable_class) do
+    Class.new do
+      include Ruboty::Env::Validatable
+
+      env :A, "description of A"
+      env :B, "description of B", optional: true
+    end
+  end
+
+  let(:instance) do
+    validatable_class.new
+  end
+
+  describe "#validate" do
+    context "without required ENV" do
+      it "raises Ruboty::Env::ValidationError" do
+        expect { instance.validate }.to raise_error(Ruboty::Env::ValidationError)
+      end
+    end
+
+    context "without optional ENV" do
+      before do
+        ENV["A"] = "dummy"
+      end
+
+      after do
+        ENV["A"] = nil
+      end
+
+      it "does nothing" do
+        expect { instance.validate }.not_to raise_error
+      end
+    end
+  end
+
+  describe "#validate!" do
+    context "without required ENV" do
+      it "dies with usage as erorr message" do
+        Ruboty.logger.should_receive(:error).with(/description of A/)
+        Ruboty.should_receive(:exit)
+        instance.validate!
+      end
+    end
+  end
+end

data/spec/ruboty/handlers/base_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+describe Ruboty::Handlers::Base do
+  after do
+    Ruboty.handlers.pop
+  end
+
+  let(:robot) do
+    Ruboty::Robot.new
+  end
+
+  let!(:handler_class) do
+    Class.new(described_class) do
+      on(/(\d+) \+ (\d+)/, name: "addition", all: true)
+
+      def addition(message)
+        robot.say(message[1].to_i + message[2].to_i)
+      end
+    end
+  end
+
+  describe ".on" do
+    it "registers an action to the handler" do
+      robot.should_receive(:say).with(2)
+      robot.receive(body: "1 + 1")
+    end
+  end
+end

data/spec/ruboty/handlers/help_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+describe Ruboty::Handlers::Help do
+  let(:robot) do
+    Ruboty::Robot.new
+  end
+
+  describe "#help" do
+    let(:from) do
+      "alice"
+    end
+
+    let(:to) do
+      "#general"
+    end
+
+    let(:body) do
+      <<-EOS.strip_heredoc.strip
+        ruboty /help( me)?\\z/i - Show this help message
+        ruboty /ping\\z/i       - Return PONG to PING
+        ruboty /who am i\\?/i   - Answer who you are
+      EOS
+    end
+
+    it "responds to `@ruboty help` and says each handler's usage" do
+      robot.should_receive(:say).with(
+        body: body,
+        code: true,
+        from: to,
+        to: from,
+        original: {
+          body: "@ruboty help",
+          from: from,
+          robot: robot,
+          to: to,
+        },
+      )
+      robot.receive(body: "@ruboty help", from: from, to: to)
+    end
+  end
+end

data/spec/ruboty/handlers/ping_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe Ruboty::Handlers::Ping do
+  let(:robot) do
+    Ruboty::Robot.new
+  end
+
+  describe "#ping" do
+    let(:from) do
+      "alice"
+    end
+
+    let(:to) do
+      "#general"
+    end
+
+    let(:said) do
+      "@ruboty ping"
+    end
+
+    let(:replied) do
+      "pong"
+    end
+
+    it "returns PONG to PING" do
+      robot.should_receive(:say).with(
+        body: replied,
+        from: to,
+        to: from,
+        original: {
+          body: said,
+          from: from,
+          robot: robot,
+          to: to,
+        },
+      )
+      robot.receive(body: said, from: from, to: to)
+    end
+  end
+end

data/spec/ruboty/handlers/whoami_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe Ruboty::Handlers::Whoami do
+  let(:robot) do
+    Ruboty::Robot.new
+  end
+
+  describe "#ping" do
+    let(:from) do
+      "alice"
+    end
+
+    let(:to) do
+      "#general"
+    end
+
+    let(:said) do
+      "@ruboty Who am I?"
+    end
+
+    it "returns PONG to PING" do
+      robot.should_receive(:say).with(
+        body: from,
+        from: to,
+        to: from,
+        original: {
+          body: said,
+          from: from,
+          robot: robot,
+          to: to,
+        },
+      )
+      robot.receive(body: said, from: from, to: to)
+    end
+  end
+end

data/spec/ruboty/robot_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe Ruboty::Robot do
+  let(:instance) do
+    described_class.new(options)
+  end
+
+  let(:options) do
+    {}
+  end
+
+  describe "#brain" do
+    context "without any Brain class" do
+      it "returns a Ruboty::Brains::Memory" do
+        instance.brain.should be_a Ruboty::Brains::Memory
+      end
+
+      it "can be used as a Hash object" do
+        instance.brain.data["a"] = 1
+        instance.brain.data["a"].should == 1
+      end
+    end
+
+    context "with another Brain class" do
+      after do
+        Ruboty::Brains::Base.brain_classes.pop
+      end
+
+      let!(:another_brain_class) do
+        Class.new(Ruboty::Brains::Base)
+      end
+
+      it "returns its instance as a Brain" do
+        instance.brain.should be_a another_brain_class
+      end
+    end
+  end
+end