twitch-bot 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b04ed5b85125452e5c58a1d4c48d308ca7d72000f09ae9768773287b242d91bf
-  data.tar.gz: a9251b16f1f8d67f8e3fb8f5ce8608628cb7649306adbbb60d6afa1119ced08d
+  metadata.gz: e127546d8abb6ccd893003d8cbbac18fbce0bb31ca01070ace83b396100e3b63
+  data.tar.gz: '0998e3ee31311c74981e00f1b1a846cfc5f6d09a18b5fd08cd8b565bcadabf33'
 SHA512:
-  metadata.gz: b831153426b24bb9af05ec085fe567c41d169e559560394a5867e95371074319c6ed1d9ea7551d52c8f74e5e6ed5ef901334e427234f19e80a1a48a24faaac9d
-  data.tar.gz: 2fb72af43444bf1ec0eeb978690150da15c9b8a1527db16423da0bde6e4a98a06df2ea2bf0834563ec00da839289960cb7ba9557733e7ab3ee3bb1283c9b14d8
+  metadata.gz: c7cfdae853bc0e994617c273ab6ba02496c0f55cbf92ba67ef4af4e46d5704e355b5bd2fa5bb677adff39d1d8e8723d0d846f9548af34998f8547282d46e71a2
+  data.tar.gz: 644b140f23c27c178b243b91ccf2ddc797c49611f83cbfccdd8987b10c79573413feae4a72fdd7956169aef897be664a4ad36c50ff7e2bd66c7c67711f29df04

data/.gitignore

@@ -12,7 +12,7 @@
 *.so
 *.o
 *.a
-mkmf.log
+*.log
 
 # rspec failure tracking
 .rspec_status

data/lib/twitch/bot/adapter/irc.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "socket"
+
+module Twitch
+  module Bot
+    module Adapter
+      # Handle the bot's IRC connection
+      class Irc
+        def initialize(client:)
+          @client = client
+
+          open_socket
+        end
+
+        def connect
+          enable_twitch_capabilities
+          authenticate
+        end
+
+        def shutdown
+          close_socket
+        end
+
+        def read_data
+          raw_message = read_data_from_socket
+          irc_message = IrcMessage.new(raw_message)
+          Twitch::Bot::MessageParser.new(irc_message).message
+        end
+
+        def send_message(text)
+          privmsg = "PRIVMSG ##{channel.name} :#{text}"
+          send_data(privmsg)
+        end
+
+        def send_data(data)
+          send_data_to_socket(data)
+        end
+
+        def join_channel(channel)
+          @channel = channel
+          send_data "JOIN ##{channel.name}"
+        end
+
+        def part_channel
+          send_data "PART ##{channel.name}"
+          @channel = nil
+        end
+
+        private
+
+        attr_reader :socket, :client, :channel
+
+        def open_socket
+          connection = client.connection
+          @socket = ::TCPSocket.new(
+            connection.hostname,
+            connection.port,
+          )
+
+          Twitch::Bot::Logger.debug "Socket open"
+        end
+
+        def close_socket
+          socket.close
+          Twitch::Bot::Logger.debug "Socket closed"
+        end
+
+        def read_data_from_socket
+          Twitch::Bot::Logger.debug "Reading socket..."
+          data = socket_read_next
+          Twitch::Bot::Logger.debug "< #{data}"
+          data
+        end
+
+        # Acceptable :reek:NilCheck
+        def socket_read_next
+          loop do
+            line = socket.gets&.chomp
+            break unless line.nil? || line.empty?
+          end
+          line
+        end
+
+        def send_data_to_socket(data)
+          Twitch::Bot::Logger.debug "> #{sanitize_data(data)}"
+          socket.puts(data)
+        end
+
+        def enable_twitch_capabilities
+          send_data <<~DATA
+            CAP REQ :twitch.tv/tags twitch.tv/commands twitch.tv/membership
+          DATA
+        end
+
+        def authenticate
+          connection = client.connection
+          send_data "PASS #{connection.password}"
+          send_data "NICK #{connection.nickname}"
+        end
+
+        def sanitize_data(data)
+          data.gsub(/(PASS oauth:)(\w+)/) do
+            "#{Regexp.last_match(1)}#{'*' * Regexp.last_match(2).size}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twitch/bot/adapter/terminal.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Twitch
+  module Bot
+    module Adapter
+      # This adapter connects the chat client to the terminal
+      class Terminal
+        def initialize(client:)
+          @client = client
+        end
+
+        def connect; end
+
+        def shutdown; end
+
+        def read_data
+          read_message_from_terminal
+        end
+
+        def send_message(text)
+          send_data(text)
+        end
+
+        def send_data(data)
+          puts sanitize_data(data)
+        end
+
+        def join_channel(_channel); end
+
+        def part_channel; end
+
+        private
+
+        attr_reader :client
+
+        def sanitize_data(data)
+          data.gsub(/(PASS oauth:)(\w+)/) do
+            "#{Regexp.last_match(1)}#{'*' * Regexp.last_match(2).size}"
+          end
+        end
+
+        def read_message_from_terminal
+          Twitch::Bot::Logger.debug "Waiting for input..."
+          input = gets
+          Twitch::Bot::Message::UserMessage.new(
+            text: input,
+            user: "tester",
+          )
+        end
+      end
+    end
+  end
+end

data/lib/twitch/bot/client.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "logger"
-require "socket"
 
 Thread.abort_on_exception = true
 
@@ -9,49 +8,6 @@ module Twitch
   module Bot
     # Twitch chat client object
     class Client
-      MODERATOR_MESSAGES_COUNT = 100
-      USER_MESSAGES_COUNT = 20
-      TWITCH_PERIOD = 30.0
-
-      # Respond to a :ping event with a pong so we don't get disconnected.
-      class PingHandler < Twitch::Bot::EventHandler
-        def call
-          client.send_data "PONG :#{event.hostname}"
-        end
-
-        def self.handled_events
-          [:ping]
-        end
-      end
-
-      # Handle the :authenticated event required for joining our channel.
-      class AuthenticatedHandler < Twitch::Bot::EventHandler
-        def call
-          client.join_default_channel
-        end
-
-        def self.handled_events
-          [:authenticated]
-        end
-      end
-
-      # Handle a change in moderators on the channel.
-      class ModeHandler < Twitch::Bot::EventHandler
-        def call
-          user = event.user
-          case event.mode
-          when :add_moderator
-            client.add_moderator(user)
-          when :remove_moderator
-            client.remove_moderator(user)
-          end
-        end
-
-        def self.handled_events
-          [:mode]
-        end
-      end
-
       # Represent the event triggered when quitting the client loop.
       class StopEvent < Twitch::Bot::Event
         def initialize
@@ -59,166 +15,151 @@ module Twitch
         end
       end
 
+      MODERATOR_MESSAGES_COUNT = 100
+      USER_MESSAGES_COUNT = 20
+      TWITCH_PERIOD = 30.0
+
       attr_reader :connection
 
       def initialize(
-        connection:, output: STDOUT, channel: nil, &block
+        connection:, channel: nil, &block
       )
         @connection = connection
-        @logger = Logger.new(output)
         @channel = Twitch::Bot::Channel.new(channel) if channel
         @messages_queue = []
-        @running = false
         @event_handlers = {}
+        @event_loop_running = false
+
+        create_adapter
 
         execute_initialize_block block if block
         register_default_handlers
       end
 
-      def trigger(event)
-        type = event.type
-        logger.debug "Triggered #{type}"
-        (event_handlers[type] || []).each do |handler_class|
-          logger.debug "Calling #{handler_class}..."
-          handler_class.new(event: event, client: self).call
-        end
-      end
-
       def register_handler(handler)
         handler.handled_events.each do |event_type|
           (event_handlers[event_type] ||= []) << handler
+          Twitch::Bot::Logger.debug "Registered #{handler} for #{event_type}"
         end
       end
 
       def run
-        raise "Already running" if running
-
-        @running = true
-
-        %w[TERM INT].each { |signal| trap(signal) { stop } }
+        startup
 
-        connect
+        # Wait for threads to finish
         input_thread.join
-        messages_thread.join
-        logger.info "Client ended."
+        output_thread.join
       end
 
-      def join(channel)
-        @channel = Channel.new(channel)
-        send_data "JOIN ##{@channel.name}"
+      def join_default_channel
+        adapter.join_channel(@channel) if @channel
       end
 
-      def part
-        send_data "PART ##{@channel.name}"
+      def part_channel
+        adapter.part_channel
         @channel = nil
         @messages_queue = []
       end
 
-      def send_message(message)
-        @messages_queue << message if @messages_queue.last != message
+      def dispatch(event)
+        type = event.type
+        Twitch::Bot::Logger.debug "Dispatching #{type}..."
+        (event_handlers[type] || []).each do |handler_class|
+          Twitch::Bot::Logger.debug "Calling #{handler_class}..."
+          handler_class.new(event: event, client: self).call
+        end
       end
 
-      def max_messages_count
-        if @channel.moderators.include?(connection.nickname)
-          MODERATOR_MESSAGES_COUNT
-        else
-          USER_MESSAGES_COUNT
-        end
+      def send_data(data)
+        adapter.send_data(data)
       end
 
-      def message_delay
-        TWITCH_PERIOD / max_messages_count
+      def send_message(message)
+        messages_queue << message if messages_queue.last != message
       end
 
       def stop
-        trigger StopEvent.new
-        @running = false
-        part if @channel
+        dispatch StopEvent.new
+        stop_event_loop
+        part_channel if channel
       end
 
-      def send_data(data)
-        log_data = data.gsub(/(PASS oauth:)(\w+)/) do
-          "#{Regexp.last_match(1)}#{'*' * Regexp.last_match(2).size}"
-        end
-        logger.debug "< #{log_data}"
+      private
 
-        socket.puts(data)
-      end
+      attr_reader :adapter, :event_handlers, :event_loop_running,
+                  :input_thread, :output_thread, :channel, :messages_queue
 
-      def join_default_channel
-        join @channel.name if @channel
+      def create_adapter
+        adapter_class = if development_mode?
+                          Twitch::Bot::Adapter::Terminal
+                        else
+                          Twitch::Bot::Adapter::Irc
+                        end
+        @adapter = adapter_class.new(client: self)
       end
 
-      def add_moderator(user)
-        channel.add_moderator(user)
+      def startup
+        set_traps
+        start_event_loop
+        start_input_thread
+        start_output_thread
+        adapter.connect
+        Twitch::Bot::Logger.debug "Started."
       end
 
-      def remove_moderator(user)
-        channel.remove_moderator(user)
+      def set_traps
+        %w[TERM INT].each { |signal| trap(signal) { stop } }
       end
 
-      private
-
-      attr_reader :event_handlers, :running, :input_thread, :messages_thread,
-                  :socket, :logger
-
-      def connect
-        @socket = ::TCPSocket.new(connection.hostname, connection.port)
+      def start_event_loop
+        raise "Already running" if event_loop_running?
 
-        start_input_thread
-        start_messages_thread
-        enable_twitch_capabilities
-        authenticate
+        @event_loop_running = true
       end
 
-      def enable_twitch_capabilities
-        send_data <<~DATA
-          CAP REQ :twitch.tv/tags twitch.tv/commands twitch.tv/membership
-        DATA
+      def stop_event_loop
+        @event_loop_running = false
       end
 
-      def authenticate
-        send_data "PASS #{connection.password}"
-        send_data "NICK #{connection.nickname}"
+      def event_loop_running?
+        @event_loop_running
       end
 
       def start_input_thread
+        Twitch::Bot::Logger.debug("Starting input thread...")
         @input_thread = Thread.start do
-          while running
-            irc_message = IrcMessage.new(read_socket)
-            trigger(Twitch::Bot::MessageParser.new(irc_message).message)
+          while event_loop_running?
+            event = adapter.read_data
+            dispatch(event)
           end
-
-          logger.debug "End of input thread"
-          socket.close
-        end
-      end
-
-      # Acceptable :reek:NilCheck
-      def read_socket
-        line = ""
-        while line.empty?
-          line = socket.gets&.chomp
         end
-        logger.debug "> #{line}"
-        line
       end
 
-      def start_messages_thread
-        @messages_thread = Thread.start do
-          while running
+      def start_output_thread
+        Twitch::Bot::Logger.debug("Starting output thread...")
+        @output_thread = Thread.start do
+          while event_loop_running?
             sleep message_delay
 
-            # TODO: Replace with core Queue
-            if (message = @messages_queue.pop)
-              send_data "PRIVMSG ##{@channel.name} :#{message}"
+            if (message = messages_queue.pop)
+              adapter.send_message(message)
             end
           end
-
-          logger.debug "End of messages thread"
         end
       end
 
+      def development_mode?
+        ENV["BOT_MODE"] == "development"
+      end
+
+      def add_moderator(user)
+        channel.add_moderator(user)
+      end
+
+      def remove_moderator(user)
+        channel.remove_moderator(user)
+      end
+
       def execute_initialize_block(block)
         if block.arity == 1
           block.call self
@@ -232,6 +173,18 @@ module Twitch
         register_handler(Twitch::Bot::Client::AuthenticatedHandler)
         register_handler(Twitch::Bot::Client::ModeHandler)
       end
+
+      def max_messages_count
+        if channel.moderators.include?(connection.nickname)
+          MODERATOR_MESSAGES_COUNT
+        else
+          USER_MESSAGES_COUNT
+        end
+      end
+
+      def message_delay
+        TWITCH_PERIOD / max_messages_count
+      end
     end
   end
 end

data/lib/twitch/bot/default_handlers.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Twitch
+  module Bot
+    # Twitch chat client object
+    class Client
+      # Respond to a :ping event with a pong so we don't get disconnected.
+      class PingHandler < Twitch::Bot::EventHandler
+        def call
+          client.send_data "PONG :#{event.hostname}"
+        end
+
+        def self.handled_events
+          [:ping]
+        end
+      end
+
+      # Handle the :authenticated event required for joining our channel.
+      class AuthenticatedHandler < Twitch::Bot::EventHandler
+        def call
+          client.join_default_channel
+        end
+
+        def self.handled_events
+          [:authenticated]
+        end
+      end
+
+      # Handle a change in moderators on the channel.
+      class ModeHandler < Twitch::Bot::EventHandler
+        def call
+          user = event.user
+          case event.mode
+          when :add_moderator
+            client.add_moderator(user)
+          when :remove_moderator
+            client.remove_moderator(user)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twitch/bot/logger.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Twitch
+  module Bot
+    class Logger
+      def self.output=(file)
+        @logger = ::Logger.new(file)
+      end
+
+      def self.level=(level)
+        @logger.level = level
+      end
+
+      def self.debug(entry)
+        logger.debug entry
+      end
+
+      def self.logger
+        @logger ||= ::Logger.new(STDOUT)
+      end
+    end
+  end
+end

data/lib/twitch/bot/message/user_message.rb

@@ -22,7 +22,7 @@ module Twitch
         end
 
         def command
-          first_word.match(/^!(\w+)/) do |match|
+          first_word&.match(/^!(\w+)/) do |match|
             match.captures&.first
           end
         end

data/lib/twitch/bot/version.rb

@@ -2,6 +2,6 @@
 
 module Twitch
   module Bot
-    VERSION = "2.0.1"
+    VERSION = "2.1.0"
   end
 end

data/lib/twitch/bot.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
 require_relative "bot/version"
+require_relative "bot/logger"
 require_relative "bot/event"
 require_relative "bot/event_handler"
+require_relative "bot/default_handlers"
 require_relative "bot/message"
 require_relative "bot/irc_message"
 require_relative "bot/message_parser"
 require_relative "bot/channel"
 require_relative "bot/connection"
+require_relative "bot/adapter/irc"
+require_relative "bot/adapter/terminal"
 require_relative "bot/client"

data/spec/twitch/bot/client_spec.rb

@@ -14,7 +14,7 @@ RSpec.describe Twitch::Bot::Client do
       message = ping_message_fake.new(:ping, "test.twitch", nil)
       allow(client).to receive(:send_data)
 
-      client.trigger(message)
+      client.dispatch(message)
 
       expect(client).to have_received(:send_data)
     end
@@ -24,7 +24,7 @@ RSpec.describe Twitch::Bot::Client do
       message = fake_message_class.new(:authenticated)
       allow(client).to receive(:join_default_channel)
 
-      client.trigger(message)
+      client.dispatch(message)
 
       expect(client).to have_received(:join_default_channel)
     end
@@ -34,7 +34,7 @@ RSpec.describe Twitch::Bot::Client do
       message = fake_message_class.new(:mode, "Test", :add_moderator)
       allow(client).to receive(:add_moderator)
 
-      client.trigger(message)
+      client.dispatch(message)
 
       expect(client).to have_received(:add_moderator)
     end
@@ -44,7 +44,7 @@ RSpec.describe Twitch::Bot::Client do
       message = fake_message_class.new(:mode, "Test", :remove_moderator)
       allow(client).to receive(:remove_moderator)
 
-      client.trigger(message)
+      client.dispatch(message)
 
       expect(client).to have_received(:remove_moderator)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: twitch-bot
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Jochen Lillich
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-16 00:00:00.000000000 Z
+date: 2020-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -187,12 +187,16 @@ files:
 - README.md
 - Rakefile
 - lib/twitch/bot.rb
+- lib/twitch/bot/adapter/irc.rb
+- lib/twitch/bot/adapter/terminal.rb
 - lib/twitch/bot/channel.rb
 - lib/twitch/bot/client.rb
 - lib/twitch/bot/connection.rb
+- lib/twitch/bot/default_handlers.rb
 - lib/twitch/bot/event.rb
 - lib/twitch/bot/event_handler.rb
 - lib/twitch/bot/irc_message.rb
+- lib/twitch/bot/logger.rb
 - lib/twitch/bot/message.rb
 - lib/twitch/bot/message/user_message.rb
 - lib/twitch/bot/message_parser.rb