twitch-bot 1.0.0

data/lib/twitch/bot/irc_message.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Twitch
+  module Bot
+    # This class parses the tags portion in an IRC message.
+    # rubocop:disable Layout/LineLength
+    # <message>       ::= ['@' <tags> <SPACE>] [':' <prefix> <SPACE> ] <command> <params> <crlf>
+    # <tags>          ::= <tag> [';' <tag>]*
+    # <tag>           ::= <key> ['=' <escaped_value>]
+    # <key>           ::= [ <client_prefix> ] [ <vendor> '/' ] <key_name>
+    # <client_prefix> ::= '+'
+    # <key_name>      ::= <non-empty sequence of ascii letters, digits, hyphens ('-')>
+    # <escaped_value> ::= <sequence of zero or more utf8 characters except NUL, CR, LF, semicolon (`;`) and SPACE>
+    # <vendor>        ::= <host>
+    # rubocop:enable Layout/LineLength
+    class IrcMessageTags
+      attr_reader :tags
+
+      def initialize(raw_tags)
+        @raw_tags = raw_tags
+        @tags = parse
+      end
+
+      def [](key)
+        @tags[key]
+      end
+
+      def include?(key)
+        @tags.key?(key)
+      end
+
+      def numeric_state(key, name, off_value:)
+        return unless tags.key?(key)
+
+        case tags[key]
+        when off_value
+          "#{name}_off".to_sym
+        else
+          name.to_sym
+        end
+      end
+
+      def boolean_state(key, name)
+        return unless tags.key?(key)
+
+        case tags[key]
+        when "1"
+          name
+        when "0"
+          "#{name}_off".to_sym
+        else
+          raise "Unsupported value of '#{key}'"
+        end
+      end
+
+      private
+
+      attr_reader :raw_tags
+
+      def parse
+        return unless raw_tags
+
+        raw_tags.
+          split(";").
+          map { |key_value| key_value.split("=", 2) }.
+          to_h
+      end
+    end
+
+    # This class parses the params portion of an IRC message.
+    class IrcMessageParams
+      attr_reader :params
+
+      def initialize(raw_params)
+        @raw_params = raw_params.strip
+        @params = parse
+      end
+
+      private
+
+      attr_reader :raw_params
+
+      def parse
+        if (match = raw_params.match(/(?:^:| :)(.*)$/))
+          params = match.pre_match.split(" ")
+          params << match[1]
+        else
+          raw_params.split(" ")
+        end
+      end
+    end
+
+    # This class splits an IRC message into its basic parts.
+    # see https://ircv3.net/specs/extensions/message-tags.html#format
+    #
+    # rubocop:disable Layout/LineLength
+    # <message>       ::= ['@' <tags> <SPACE>] [':' <prefix> <SPACE> ] <command> <params> <crlf>
+    # rubocop:enable Layout/LineLength
+    class IrcMessage
+      attr_reader :tags, :prefix, :command, :params
+
+      def initialize(msg)
+        raw_tags, @prefix, @command, raw_params = msg.match(
+          /^(?:@(\S+) )?(?::(\S+) )?(\S+)(.*)/,
+        ).captures
+
+        @tags = IrcMessageTags.new(raw_tags)
+        @params = IrcMessageParams.new(raw_params).params
+      end
+
+      def error
+        command[/[45]\d\d/] ? command.to_i : 0
+      end
+
+      def error?
+        error.positive?
+      end
+
+      def target
+        channel || user
+      end
+
+      def text
+        if error?
+          error.to_s
+        else
+          params.last
+        end
+      end
+
+      def user
+        return unless prefix
+
+        prefix[/^(\S+)!/, 1]
+      end
+
+      # Not really a :reek:NilCheck
+      def channel
+        params.detect { |param| param.start_with?("#") }&.delete("#")
+      end
+    end
+  end
+end

data/lib/twitch/bot/message_parser.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Twitch
+  module Bot
+    # This class calls the parser related to the IRC command we received.
+    class MessageParser
+      def initialize(irc_message)
+        @irc_message = irc_message
+      end
+
+      def message
+        parse_command
+      end
+
+      private
+
+      attr_reader :irc_message
+
+      def parse_command
+        command_parser = {
+          "MODE" => ModeCommandParser,
+          "PING" => PingCommandParser,
+          "372" => AuthenticatedCommandParser,
+          "366" => JoinCommandParser,
+          "PRIVMSG" => PrivMsgCommandParser,
+          "ROOMSTATE" => RoomStateCommandParser,
+          "NOTICE" => NoticeCommandParser,
+        }
+        parser = command_parser[irc_message.command]
+        if parser
+          parser.new(irc_message).call
+        else
+          NotSupportedMessage.new(irc_message)
+        end
+      end
+    end
+
+    # Abstract base class for a parser for a specific IRC command.
+    class CommandParser
+      attr_reader :message
+
+      def initialize(message)
+        @message = message
+      end
+    end
+
+    # Parses a PING IRC command
+    class PingCommandParser < CommandParser
+      def call
+        PingMessage.new(message)
+      end
+    end
+
+    # Parses a PRIVMSG IRC command
+    class PrivMsgCommandParser < CommandParser
+      def call
+        if message.user == "twitchnotify"
+          if message.text.match?(/just subscribed!/)
+            SubscriptionMessage.new(message)
+          else
+            NotSupportedMessage.new(message)
+          end
+        else
+          ChatMessageMessage.new(message)
+        end
+      end
+    end
+
+    # Parses a MODE IRC command
+    class ModeCommandParser < CommandParser
+      def call
+        ModeMessage.new(message)
+      end
+    end
+
+    # Parses a 372 IRC status code/command.
+    class AuthenticatedCommandParser < CommandParser
+      def call
+        AuthenticatedMessage.new(message)
+      end
+    end
+
+    # Parses a 366 IRC status code/command.
+    class JoinCommandParser < CommandParser
+      def call
+        JoinMessage.new(message)
+      end
+    end
+
+    # Parses a ROOMSTATE IRC command.
+    class RoomStateCommandParser < CommandParser
+      def call
+        roomstate_tags = {
+          "slow" => SlowModeMessage,
+          "followers-only" => FollowersOnlyModeMessage,
+          "subs-only" => SubsOnlyModeMessage,
+          "r9k" => R9kModeMessage,
+        }
+
+        roomstate_tags.each do |tag, event|
+          if message.tags.include?(tag)
+            return event.new(message)
+          end
+        end
+
+        NotSupportedMessage.new(message)
+      end
+    end
+
+    # Parses a NOTICE IRC command.
+    class NoticeCommandParser < CommandParser
+      def call
+        if message.params.last.match?(/Login authentication failed/)
+          LoginFailedMessage.new(message)
+        else
+          NotSupportedMessage.new(message)
+        end
+      end
+    end
+  end
+end

data/lib/twitch/bot/twitch_message.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+# TODO: Use namespace
+
+module Twitch
+  module Bot
+    # This class is the abstract base class for IRC events.
+    class TwitchMessage < Twitch::Bot::Event
+      def initialize(_message)
+        @type = :unknown
+      end
+    end
+
+    # This class represents an event that is not supported.
+    class NotSupportedMessage < TwitchMessage
+      attr_reader :message
+
+      def initialize(message)
+        @message = message
+        @type = :not_supported
+      end
+    end
+
+    # This class stores the details of a Ping event.
+    class PingMessage < TwitchMessage
+      attr_reader :hostname, :user
+
+      def initialize(message)
+        @user = message.user
+        @hostname = message.params.last
+        @type = :ping
+      end
+    end
+
+    # This class stores the details of a Mode event.
+    class ModeMessage < TwitchMessage
+      attr_reader :user, :mode
+
+      MODE_CHANGE = {
+        "+o" => :add_moderator,
+        "-o" => :remove_moderator,
+      }.freeze
+      def initialize(message)
+        params = message.params
+        @user = params.last
+        @mode = MODE_CHANGE[params[1]]
+        @type = :mode
+      end
+    end
+
+    # This class stores the details of an Authenticated event.
+    class AuthenticatedMessage < TwitchMessage
+      def initialize(_message)
+        @type = :authenticated
+      end
+    end
+
+    # This class stores the details of a Join event.
+    class JoinMessage < TwitchMessage
+      def initialize(_message)
+        @type = :join
+      end
+    end
+
+    # This class stores the details of a Subscription event.
+    class SubscriptionMessage < TwitchMessage
+      attr_reader :user
+
+      def initialize(message)
+        @user = message.params.last.split(" ").first
+        @type = :subscription
+      end
+    end
+
+    # This class stores the details of a ChatMessage event.
+    class ChatMessageMessage < TwitchMessage
+      attr_reader :text, :user
+
+      def initialize(message)
+        @text = message.text
+        @user = message.user
+        @type = :chat_message
+      end
+
+      def bot_command?(command)
+        text.split(/\s+/).first.match?(/^!#{command}/)
+      end
+    end
+
+    # This class stores the details of a LoginFailed event.
+    class LoginFailedMessage < TwitchMessage
+      attr_reader :user
+
+      def initialize(message)
+        @user = message.user
+        @type = :login_failed
+      end
+    end
+
+    # This class stores the details of a SlowMode event.
+    class SlowModeMessage < TwitchMessage
+      attr_reader :status, :channel
+
+      def initialize(message)
+        @status = message.tags["slow"]
+        @channel = message.channel
+        @type = :slow_mode
+      end
+
+      def enabled?
+        status.to_i.positive?
+      end
+    end
+
+    # This class stores the details of a FollowersOnlyMode event.
+    class FollowersOnlyModeMessage < TwitchMessage
+      attr_reader :status
+
+      def initialize(message)
+        @status = message.tags["followers-only"]
+        @type = :followers_only_mode
+      end
+    end
+
+    # This class stores the details of a SubsOnlyMode event.
+    class SubsOnlyModeMessage < TwitchMessage
+      attr_reader :status, :channel
+
+      def initialize(message)
+        @status = message.tags["subs-only"]
+        @channel = message.channel
+        @type = :subs_only_mode
+      end
+    end
+
+    # This class stores the details of a R9kMode event.
+    class R9kModeMessage < TwitchMessage
+      attr_reader :status, :channel
+
+      def initialize(message)
+        @status = message.tags["r9k"]
+        @channel = message.channel
+        @type = :r9k_mode
+      end
+    end
+  end
+end

data/lib/twitch/bot/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Twitch
+  module Bot
+    VERSION = "1.0.0"
+  end
+end

data/lib/twitch/bot.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "bot/version"
+require_relative "bot/event"
+require_relative "bot/event_handler"
+require_relative "bot/twitch_message"
+require_relative "bot/irc_message"
+require_relative "bot/message_parser"
+require_relative "bot/channel"
+require_relative "bot/connection"
+require_relative "bot/client"

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "pry-byebug"
+require_relative "../lib/twitch/bot"

data/spec/twitch/bot/client_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+describe Twitch::Bot::Client do
+  let!(:client) do
+    connection = Twitch::Bot::Connection.new(
+      nickname: "test", password: "test",
+    )
+    described_class.new(connection: connection)
+  end
+
+  describe "#trigger" do
+    it "responds to a Ping message" do
+      ping_message_fake = Struct.new(:type, :hostname, :user)
+      message = ping_message_fake.new(:ping, "test.twitch", nil)
+      allow(client).to receive(:send_data)
+
+      client.trigger(message)
+
+      expect(client).to have_received(:send_data)
+    end
+
+    it "responds to an Authenticate message" do
+      fake_message_class = Struct.new(:type)
+      message = fake_message_class.new(:authenticated)
+      allow(client).to receive(:join_default_channel)
+
+      client.trigger(message)
+
+      expect(client).to have_received(:join_default_channel)
+    end
+
+    it "responds to a +o message" do
+      fake_message_class = Struct.new(:type, :user, :mode)
+      message = fake_message_class.new(:mode, "Test", :add_moderator)
+      allow(client).to receive(:add_moderator)
+
+      client.trigger(message)
+
+      expect(client).to have_received(:add_moderator)
+    end
+
+    it "responds to a -o message" do
+      fake_message_class = Struct.new(:type, :user, :mode)
+      message = fake_message_class.new(:mode, "Test", :remove_moderator)
+      allow(client).to receive(:remove_moderator)
+
+      client.trigger(message)
+
+      expect(client).to have_received(:remove_moderator)
+    end
+  end
+end

data/spec/twitch/bot/message_parser_spec.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+describe Twitch::Bot::MessageParser do
+  context "when we receive a PRIVMSG message" do
+    it "parses a chat message event" do
+      irc_message = Twitch::Bot::IrcMessage.new(<<~RAW)
+        :enotpoloskun!enotpoloskun@enotpoloskun.tmi.twitch.tv PRIVMSG #enotpoloskun :BibleThump
+      RAW
+
+      event = described_class.new(irc_message).message
+
+      expect(event.type).to eq :chat_message
+      expect(event.text).to eq "BibleThump"
+      expect(event.user).to eq "enotpoloskun"
+    end
+
+    it "parses a slow_mode enable event" do
+      irc_message = Twitch::Bot::IrcMessage.new(<<~RAW)
+        @room-id=117474239;slow=10 :tmi.twitch.tv ROOMSTATE #alexwayfer
+      RAW
+
+      event = described_class.new(irc_message).message
+
+      expect(event.type).to eq :slow_mode
+      expect(event.status).to eq "10"
+      expect(event.channel).to eq "alexwayfer"
+    end
+
+    it "parses a slow mode disable event" do
+      irc_message = Twitch::Bot::IrcMessage.new(<<~RAW)
+        @room-id=117474239;slow=0 :tmi.twitch.tv ROOMSTATE #alexwayfer
+      RAW
+
+      event = described_class.new(irc_message).message
+
+      expect(event.type).to eq :slow_mode
+      expect(event.status).to eq "0"
+      expect(event.channel).to eq "alexwayfer"
+    end
+
+    it "parses an r9k mode enable event" do
+      irc_message = Twitch::Bot::IrcMessage.new(<<~RAW)
+        @r9k=1;room-id=117474239 :tmi.twitch.tv ROOMSTATE #alexwayfer
+      RAW
+
+      event = described_class.new(irc_message).message
+
+      expect(event.type).to eq :r9k_mode
+      expect(event.status).to eq "1"
+      expect(event.channel).to eq "alexwayfer"
+    end
+
+    it "parses an r9k mode disable event" do
+      irc_message = Twitch::Bot::IrcMessage.new(<<~RAW)
+        @r9k=0;room-id=117474239 :tmi.twitch.tv ROOMSTATE #alexwayfer
+      RAW
+
+      event = described_class.new(irc_message).message
+
+      expect(event.type).to eq :r9k_mode
+      expect(event.status).to eq "0"
+      expect(event.channel).to eq "alexwayfer"
+    end
+
+    it "parses a subs-only mode enable event" do
+      irc_message = Twitch::Bot::IrcMessage.new(<<~RAW)
+        @room-id=128644134;subs-only=1 :tmi.twitch.tv ROOMSTATE #sad_satont
+      RAW
+
+      event = described_class.new(irc_message).message
+
+      expect(event.type).to eq :subs_only_mode
+      expect(event.channel).to eq "sad_satont"
+    end
+
+    it "parses a subs-only mode disable event" do
+      irc_message = Twitch::Bot::IrcMessage.new(<<~RAW)
+        @room-id=128644134;subs-only=0 :tmi.twitch.tv ROOMSTATE #sad_satont
+      RAW
+
+      event = described_class.new(irc_message).message
+
+      expect(event.type).to eq :subs_only_mode
+      expect(event.channel).to eq "sad_satont"
+    end
+
+    it "handles a subscription event" do
+      irc_message = Twitch::Bot::IrcMessage.new(<<~RAW)
+        :twitchnotify!twitchnotify@twitchnotify.tmi.twitch.tv PRIVMSG #enotpoloskun :enotpoloskun just subscribed!
+      RAW
+
+      event = described_class.new(irc_message).message
+
+      expect(event.type).to eq :subscription
+      expect(event.user).to eq "enotpoloskun"
+    end
+  end
+
+  it "handles a MODE event" do
+    irc_message = Twitch::Bot::IrcMessage.new(<<~RAW)
+      :jtv MODE #enotpoloskun +o enotpoloskun
+    RAW
+
+    event = described_class.new(irc_message).message
+
+    expect(event.user).to eq "enotpoloskun"
+    expect(event.type).to eq :mode
+  end
+
+  it "parses a PING event" do
+    host = "tmi.twitch.tv"
+    irc_message = Twitch::Bot::IrcMessage.new(<<~RAW)
+      PING :#{host}
+    RAW
+
+    event = described_class.new(irc_message).message
+
+    expect(event.user).to eq nil
+    expect(event.type).to eq :ping
+    expect(event.hostname).to eq host
+  end
+
+  it "parses a NOTIFY event" do
+    irc_message = Twitch::Bot::IrcMessage.new(<<~RAW)
+      :tmi.twitch.tv NOTICE * :Login authentication failed
+    RAW
+
+    event = described_class.new(irc_message).message
+
+    expect(event.user).to eq nil
+    expect(event.type).to eq :login_failed
+  end
+end

data/twitch-bot.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "lib/twitch/bot/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "twitch-bot"
+  spec.version       = Twitch::Bot::VERSION
+  spec.authors       = ["Jochen Lillich"]
+  spec.email         = ["contact@geewiz.dev"]
+  spec.summary       = <<~SUMMARY
+    twitch-bot is a Twitch chat client that uses Twitch IRC that can be used as a Twitch chat bot engine.
+  SUMMARY
+  spec.description = <<~DESC
+    twitch-bot is a Twitch chat client that uses Twitch IRC.
+    With the help of this library you can connect to any Twitch channel and handle chat events.
+  DESC
+  spec.homepage      = "https://github.com/geewiz/twitch-bot"
+  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_development_dependency "bundler", "~> 2.0"
+  spec.add_development_dependency "freistil-rubocop"
+  spec.add_development_dependency "guard", "~> 2.16"
+  spec.add_development_dependency "guard-rspec", "~> 4.7"
+  spec.add_development_dependency "pry-byebug", "~> 3.0"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "reek"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "solargraph"
+  spec.add_development_dependency "terminal-notifier-guard"
+end