pug-bot 0.1.0

data/lib/pug/results.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Pug
+  # Convenience methods for common Results
+  class Results
+    def self.unknown_input
+      Types::Result.error(Strings.unknown_input)
+    end
+
+    def self.missing_actions
+      Types::Result.error(Strings.no_actions)
+    end
+
+    def self.invalid_index(index)
+      Types::Result.error(Strings.unable_to_start_action(index))
+    end
+
+    def self.enter_inputs(action_name)
+      Types::Result.info(Strings.enter_inputs(action_name))
+    end
+
+    def self.no_action_running
+      Types::Result.error(Strings.no_action_running)
+    end
+  end
+end

data/lib/pug/strings.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Pug
+  # Convenience methods for user facing strings
+  class Strings
+    def self.no_action_running
+      'There is no action currently running.'
+    end
+
+    def self.error_occurred
+      'An error occurred acting on your action'
+    end
+
+    def self.finished_running(action_name)
+      "Finished running #{action_name}"
+    end
+
+    def self.unable_to_start_action(index)
+      "Unable to start action at index: #{index}"
+    end
+
+    def self.enter_inputs(action_name)
+      "Enter inputs for #{action_name}"
+    end
+
+    def self.unknown_input
+      "Sorry, I don't understand that input."
+    end
+
+    def self.no_actions
+      'There are no actions available to run. Did you set some up?'
+    end
+
+    def self.help(commands)
+      "These are available commands:\n#{commands}"
+    end
+  end
+end

data/lib/pug/telegram_client.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'telegram/bot'
+
+module Pug
+  # The client for Telegram interactions
+  class TelegramClient < Interfaces::Client
+    # @param token [String] API token for Telegram bot
+    # @param chat_id [String] Chat id for Telegram bot
+    def initialize(token, chat_id)
+      @token = token
+      @chat_id = chat_id
+    end
+
+    # Configures keyboard with provided markup
+    # This can be useful to make shortcuts for Commands
+    # @param keyboard_markup [Array<Array<String>>]
+    #   A 2D array of strings used to populate on the keyboard
+    def configure_keyboard(keyboard_markup)
+      @keyboard_markup = keyboard_markup || []
+    end
+
+    # Override of {Interfaces::Client#listen}
+    # @yieldparam [String] text
+    def listen
+      perform_with_bot do |bot|
+        bot.listen do |message|
+          next if message.nil?
+          text = message.text
+          next if text.nil?
+          yield text
+        end
+      end
+    end
+
+    # Override of {Interfaces::Client#send_message}
+    # @return [void]
+    def send_message(message)
+      return if message.to_s.empty?
+      send_telegram_message(message)
+    end
+
+    private
+
+    def send_telegram_message(message)
+      reply_markup = Telegram::Bot::Types::ReplyKeyboardMarkup.new(
+        keyboard: @keyboard_markup || []
+      )
+      perform_with_bot do |bot|
+        bot.api.send_message(
+          chat_id: @chat_id,
+          text: message,
+          reply_markup: reply_markup
+        )
+      end
+    end
+
+    def client
+      return @client if @client
+      raise 'No Telegram token provided' if @token.to_s.empty?
+      @client = Telegram::Bot::Client.new(@token)
+    end
+
+    def perform_with_bot
+      yield client
+    rescue StandardError => ex
+      puts 'Error performing task with Telegram'
+      puts ex
+      puts ex.backtrace
+    end
+  end
+end

data/lib/pug/terminal_client.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Pug
+  # The client for Terminal interactions
+  class TerminalClient < Interfaces::Client
+    # Override of {Interfaces::Client#listen}
+    # @yieldparam [String] text
+    def listen
+      loop do
+        message = gets
+        yield message.chomp
+      end
+    end
+
+    # Override of {Interfaces::Client#send_message}
+    # @return [void]
+    def send_message(message)
+      return if message.to_s.empty?
+      puts message.green
+    end
+  end
+end
+
+# Helper class used to spice up Terminal output
+class String
+  def colorize(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end
+
+  def green
+    colorize(32)
+  end
+end

data/lib/pug/types/result.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Pug
+  module Types
+    # Encapsulates a sucess/failure result
+    # @!attribute type
+    #   @return [Integer] the type of the Result
+    #   @see Result::SUCCESS
+    #   @see Result::INFO
+    #   @see Result::ERROR
+    # @!attribute value
+    #   @return [String] the value of the Result
+    #   @note exists only for SUCCESS and INFO types
+    # @!attribute error
+    #   @return [String] the output of the Action
+    #   @note exists only for ERROR type
+    class Result
+      attr_reader :type, :value, :error
+      private_class_method :new
+
+      # @!group Types
+      SUCCESS = 0
+      INFO = 1
+      ERROR = 2
+      # @!endgroup
+
+      # @!visibility private
+      def initialize(type, value, error)
+        raise 'Invalid type' unless [SUCCESS, INFO, ERROR].include?(type)
+        @type = type
+        @value = value
+        @error = error
+      end
+
+      # Defines a SUCCESS Result
+      # @param value [String] value for Result
+      # @return [Result] with value and no error
+      def self.success(value)
+        new(SUCCESS, value, nil)
+      end
+
+      # Defines an INFO Result
+      # @param value [String] value for Result
+      # @return [Result] with value and no error
+      def self.info(value)
+        new(INFO, value, nil)
+      end
+
+      # Defines an ERROR Result
+      # @param error [String] error for Result
+      # @return [Result] with error and no value
+      def self.error(error)
+        new(ERROR, nil, error)
+      end
+    end
+  end
+end

data/lib/pug/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Pug
+  VERSION = '0.1.0'
+end

data/lib/pug.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'pug/action/controller'
+require 'pug/action/enumerator'
+require 'pug/action/input'
+require 'pug/action/output'
+require 'pug/clients/factory'
+require 'pug/interfaces/action'
+require 'pug/interfaces/client'
+require 'pug/types/result'
+require 'pug/bot'
+require 'pug/configuration'
+require 'pug/keyword_handler'
+require 'pug/message_handler'
+require 'pug/number_parser'
+require 'pug/results'
+require 'pug/strings'
+require 'pug/telegram_client'
+require 'pug/terminal_client'
+require 'pug/version'
+
+# An automation framework for repetitive dev tasks
+# @!attribute configuration
+#   @return [Configuration] the Pug config object
+module Pug # :nodoc:
+  class << self
+    attr_writer :configuration
+  end
+
+  # Grabs the current Pug configuration
+  # @return [Configuration] the Pug config object
+  def self.configuration
+    default_type = Configuration::TELEGRAM
+    @configuration ||= Configuration.new(default_type)
+  end
+
+  # @yieldparam [Configuration] configuration
+  def self.configure
+    yield(configuration)
+  end
+end

data/pug-bot.gemspec

@@ -0,0 +1,23 @@
+require 'pug/version'
+
+Gem::Specification.new do |s|
+  s.name          = 'pug-bot'
+  s.version       = Pug::VERSION
+  s.authors       = ['Alex Figueroa']
+  s.email         = 'alexjfigueroa [ at ] gmail [ dot ] com'
+
+  s.summary       = 'An automation framework for repetitive dev tasks'
+  s.homepage      = 'https://github.com/ajfigueroa/pug-bot'
+  s.license       = 'MIT'
+
+  s.files         = Dir['lib/**/*'] + %w(Gemfile LICENSE README.md Rakefile pug-bot.gemspec)
+  s.test_files    = Dir['spec/**/*']
+  s.require_paths = ['lib']
+  s.required_ruby_version = '>= 2.3'
+
+  s.add_runtime_dependency 'telegram-bot-ruby', '~> 0.8.6', '>= 0.8.6'
+
+  s.add_development_dependency 'rspec', '~> 3.7.0', '>= 3.7.0'
+  s.add_development_dependency 'rubocop', '~> 0.53.0', '>= 0.53.0'
+  s.add_development_dependency 'yard', '~> 0.9.2', '>= 0.9.2'
+end

data/spec/lib/pug/action/controller_spec.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require 'pug'
+require_relative '../../spec_helpers/mock_action'
+
+describe Pug::Action::Controller do
+  describe 'actions?' do
+    it 'should return false for nil actions' do
+      controller = Pug::Action::Controller.new(nil)
+      expect(controller.actions?).to be false
+    end
+
+    it 'should return false for empty actions' do
+      controller = Pug::Action::Controller.new([])
+      expect(controller.actions?).to be false
+    end
+
+    it 'should return true for any actions' do
+      action = MockAction.new('Command')
+      controller = Pug::Action::Controller.new([action])
+      expect(controller.actions?).to be true
+    end
+  end
+
+  describe 'running_action?' do
+    it 'should return false when not running a action' do
+      action = MockAction.new('Command')
+      controller = Pug::Action::Controller.new([action])
+      expect(controller.running_action?).to be false
+    end
+
+    it 'should return true when running a action' do
+      action = MockAction.new('Command')
+      controller = Pug::Action::Controller.new([action])
+      controller.start_action(0)
+      expect(controller.running_action?).to be true
+    end
+  end
+
+  describe 'action_input' do
+    it 'should raise an error when not running a action' do
+      action = MockAction.new('Command')
+      controller = Pug::Action::Controller.new([action])
+      expect { controller.action_input }.to raise_error(RuntimeError)
+    end
+
+    it 'should indicate false when running action requires no inputs' do
+      action = MockAction.new('Command', false)
+      controller = Pug::Action::Controller.new([action])
+      controller.start_action(0)
+      input = controller.action_input
+      expect(input.required?).to be false
+    end
+
+    it 'should indicate true when running action requires inputs' do
+      action = MockAction.new('Command', true)
+      controller = Pug::Action::Controller.new([action])
+      controller.start_action(0)
+      input = controller.action_input
+      expect(input.required?).to be true
+    end
+  end
+
+  describe 'can_start_action?' do
+    it 'should return false for out of bounds index' do
+      action = MockAction.new('Command')
+      controller = Pug::Action::Controller.new([action])
+      expect(controller.can_start_action?(-1)).to be false
+      expect(controller.can_start_action?(1)).to be false
+    end
+
+    it 'should return false if there is already a running action' do
+      action = MockAction.new('Command')
+      controller = Pug::Action::Controller.new([action])
+      controller.start_action(0)
+      expect(controller.can_start_action?(0)).to be false
+    end
+
+    it 'should return true if there is no already running action' do
+      action = MockAction.new('Command')
+      controller = Pug::Action::Controller.new([action])
+      expect(controller.can_start_action?(0)).to be true
+    end
+  end
+
+  describe 'start_action' do
+    it 'should not start running a action if it can not start action' do
+      action = MockAction.new('Command')
+      controller = Pug::Action::Controller.new([action])
+      controller.start_action(10)
+      expect(controller.running_action?).to be false
+    end
+
+    it 'should start running a action if it can start action' do
+      action = MockAction.new('Command')
+      controller = Pug::Action::Controller.new([action])
+      controller.start_action(0)
+      expect(controller.running_action?).to be true
+    end
+  end
+
+  describe 'run_action' do
+    it 'should return an error result if not running action' do
+      action = MockAction.new('Command')
+      controller = Pug::Action::Controller.new([action])
+      allow(action).to receive(:requires_inputs?) { true }
+      result = controller.run_action('')
+      expect(result.type).to eq(Pug::Types::Result::ERROR)
+      expect(result.error).to eq(Pug::Strings.no_action_running)
+    end
+
+    it 'should return success with empty string if action has no output' do
+      action = MockAction.new('Command', true, nil)
+      controller = Pug::Action::Controller.new([action])
+      controller.start_action(0)
+      result = controller.run_action('')
+      expect(result.type).to eq(Pug::Types::Result::SUCCESS)
+      expect(result.value.value).to be_empty
+    end
+
+    it 'should return success with output if action has an output' do
+      action = MockAction.new('Command', true, 'Output')
+      controller = Pug::Action::Controller.new([action])
+      controller.start_action(0)
+      result = controller.run_action('')
+      expect(result.type).to eq(Pug::Types::Result::SUCCESS)
+      expect(result.value.value).to eq('Output')
+    end
+
+    it 'should clear the running action' do
+      action = MockAction.new('Command', true, 'Output')
+      controller = Pug::Action::Controller.new([action])
+      controller.start_action(0)
+      controller.run_action('')
+      expect(controller.running_action?).to be false
+    end
+  end
+end

data/spec/lib/pug/action/enumerator_spec.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'pug'
+require_relative '../../spec_helpers/mock_action'
+
+describe Pug::Action::Enumerator do
+  describe 'names' do
+    it 'should return an empty array for nil actions' do
+      enumerator = Pug::Action::Enumerator.new
+      expect(enumerator.names(nil)).to be_empty
+    end
+
+    it 'should return an empty array for empty actions' do
+      enumerator = Pug::Action::Enumerator.new
+      expect(enumerator.names([])).to be_empty
+    end
+
+    it 'should return a single enumeration for a single action' do
+      action = MockAction.new('Command')
+      enumerator = Pug::Action::Enumerator.new
+      expect(enumerator.names([action])).to eq(['0: Command'])
+    end
+
+    it 'should return multiple enumerations for multiple actions' do
+      action0 = MockAction.new('Command0')
+      action1 = MockAction.new('Command1')
+      action2 = MockAction.new('Command2')
+      actions = [action0, action1, action2]
+      enumerator = Pug::Action::Enumerator.new
+      expected = ['0: Command0', '1: Command1', '2: Command2']
+      expect(enumerator.names(actions)).to eq(expected)
+    end
+
+    it 'should not show the description if it is nil' do
+      action = MockAction.new('Command')
+      action.mock_description = nil
+      enumerator = Pug::Action::Enumerator.new
+      expect(enumerator.names([action], true)).to eq(['0: Command'])
+    end
+
+    it 'should not show the description if it is empty' do
+      action = MockAction.new('Command')
+      enumerator = Pug::Action::Enumerator.new
+      expect(enumerator.names([action], true)).to eq(['0: Command'])
+    end
+
+    it 'should show the description if it is valid' do
+      action = MockAction.new('Command')
+      action.mock_description = 'ABOUT'
+      enumerator = Pug::Action::Enumerator.new
+      expect(enumerator.names([action], true)).to eq(['0: Command # ABOUT'])
+    end
+  end
+
+  describe 'grouped_names' do
+    it 'should return an empty array for nil actions' do
+      enumerator = Pug::Action::Enumerator.new
+      expect(enumerator.grouped_names(nil)).to be_empty
+    end
+
+    it 'should return an empty array for a negative group size' do
+      action = MockAction.new('Command')
+      enumerator = Pug::Action::Enumerator.new
+      expect(enumerator.grouped_names([action], -10)).to eq([])
+    end
+
+    it 'should return an empty array for a group size of 0' do
+      action = MockAction.new('Command')
+      enumerator = Pug::Action::Enumerator.new
+      expect(enumerator.grouped_names([action], 0)).to eq([])
+    end
+
+    it 'should return an empty array for empty actions' do
+      enumerator = Pug::Action::Enumerator.new
+      expect(enumerator.grouped_names([])).to be_empty
+    end
+
+    it 'should return a subarray when less actions than group size' do
+      action = MockAction.new('Command')
+      enumerator = Pug::Action::Enumerator.new
+      expected = [['0: Command']]
+      expect(enumerator.grouped_names([action], 10)).to eq(expected)
+    end
+
+    it 'should return a subarray when equal actions to group size' do
+      action0 = MockAction.new('Command0')
+      action1 = MockAction.new('Command1')
+      actions = [action0, action1]
+      enumerator = Pug::Action::Enumerator.new
+      expected = [['0: Command0', '1: Command1']]
+      expect(enumerator.grouped_names(actions, 2)).to eq(expected)
+    end
+
+    it 'should return multiple subarrays when more actions than group size' do
+      action0 = MockAction.new('Command0')
+      action1 = MockAction.new('Command1')
+      action2 = MockAction.new('Command2')
+      actions = [action0, action1, action2]
+      enumerator = Pug::Action::Enumerator.new
+      expected = [['0: Command0', '1: Command1'], ['2: Command2']]
+      expect(enumerator.grouped_names(actions, 2)).to eq(expected)
+    end
+  end
+end

data/spec/lib/pug/bot_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'pug'
+require_relative '../spec_helpers/mock_action'
+require_relative '../spec_helpers/mock_client'
+
+describe Pug::Bot do
+  describe 'start' do
+    before(:each) do
+      @client = MockClient.new
+      action0 = MockAction.new('Action0', false, 'Output0')
+      action1 = MockAction.new('Action1', true, 'Output1')
+      @bot = Pug::Bot.new(@client, [action0, action1])
+    end
+
+    it 'should respond to "help" command' do
+      @client.enqueue_message('help')
+      expected = Pug::Strings.help('list')
+      @bot.start
+      expect(@client.last_sent_message).to eq(expected)
+    end
+
+    it 'should respond to "list" command' do
+      @client.enqueue_message('list')
+      expected = "0: Action0\n1: Action1"
+      @bot.start
+      expect(@client.last_sent_message).to eq(expected)
+    end
+
+    describe 'when there are no commands' do
+      it 'should indicate there are no commands' do
+        client = MockClient.new
+        client.enqueue_message('0')
+        bot = Pug::Bot.new(client, [])
+        expected = Pug::Strings.no_actions
+        bot.start
+        expect(client.last_sent_message).to eq(expected)
+      end
+    end
+
+    describe 'when a command is not running' do
+      it 'should respond to an unknown input' do
+        @client.enqueue_message('asdfadf')
+        expected = Pug::Strings.unknown_input
+        @bot.start
+        expect(@client.last_sent_message).to eq(expected)
+      end
+
+      it 'should respond to an action call with no inputs required' do
+        @client.enqueue_message('0')
+        expected0 = 'Output0'
+        expected1 = Pug::Strings.finished_running('Action0')
+        @bot.start
+        expect(@client.sent_messages).to eq([expected0, expected1])
+      end
+
+      it 'should respond to an action call with inputs required' do
+        @client.enqueue_message('1')
+        expected = Pug::Strings.enter_inputs('Action1')
+        @bot.start
+        expect(@client.last_sent_message).to eq(expected)
+      end
+    end
+
+    describe 'when a command is running' do
+      it 'should pass the input and run the command awaiting input' do
+        @client.enqueue_message('1')
+        @client.enqueue_message('Input')
+        expected0 = Pug::Strings.enter_inputs('Action1')
+        expected1 = 'Output1'
+        expected2 = Pug::Strings.finished_running('Action1')
+        expected = [expected0, expected1, expected2]
+        @bot.start
+        expect(@client.sent_messages).to eq(expected)
+      end
+    end
+  end
+end

data/spec/lib/pug/clients/factory_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'pug'
+
+describe Pug::Clients::Factory do
+  describe 'client_for_config' do
+    it 'should return terminal for a nil config' do
+      client = Pug::Clients::Factory.client_for_config(nil)
+      expect(client).to be_an_instance_of(Pug::TerminalClient)
+    end
+
+    it 'should return terminal for a terminal config' do
+      config = Pug::Configuration.new(Pug::Configuration::TERMINAL)
+      client = Pug::Clients::Factory.client_for_config(config)
+      expect(client).to be_an_instance_of(Pug::TerminalClient)
+    end
+
+    it 'should return telegram for a telegram config' do
+      config = Pug::Configuration.new(Pug::Configuration::TELEGRAM)
+      client = Pug::Clients::Factory.client_for_config(config)
+      expect(client).to be_an_instance_of(Pug::TelegramClient)
+    end
+  end
+end