twitch-bot 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a10dd280ea4e2cf20e4d4066f119b13622aae30e7d03f9bd3c6407113b05e5b8
+  data.tar.gz: 58c80ab7b5c89b67e317986713e854d4797048bca8d5cde5c11da2966022a54f
+SHA512:
+  metadata.gz: c8c987740eff97e5b02e8b0b3a9c996d43948de76cedfe3ba83464c9115f025b81691f0de167cdaa91a82a4499d5c1a88ac5d926d1260f7a76b7ea280b7b9d02
+  data.tar.gz: 00a30a330696adbbf506fc4858b52a8e1cb4670ad56a49606433ad05d185868f62bed7ca4e09b0758a40d8817cd513ce59c10cd099e979b64fbf04209eb707b4

data/.editorconfig

@@ -0,0 +1,13 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.yml]
+indent_style = space
+indent_size = 2

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/bin/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,8 @@
+inherit_gem:
+  freistil-rubocop:
+    - default.yml
+
+AllCops:
+  Exclude:
+    - bin/rake
+    - bin/rspec

data/.ruby-version

@@ -0,0 +1 @@
+2.6.5

data/.vscode/launch.json

@@ -0,0 +1,28 @@
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "RSpec - active spec file only",
+      "type": "Ruby",
+      "request": "launch",
+      "cwd": "${workspaceRoot}",
+      "program": "${workspaceRoot}/bin/rspec",
+      "args": [
+        "${file}"
+      ]
+    },
+    {
+      "name": "Rspec - all spec files",
+      "type": "Ruby",
+      "request": "launch",
+      "cwd": "${workspaceRoot}",
+      "program": "${workspaceRoot}/bin/rspec",
+      "args": [
+        "spec"
+      ]
+    }
+  ]
+}

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at TODO: Write your email address. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [https://contributor-covenant.org/version/1/4][version]
+
+[homepage]: https://contributor-covenant.org
+[version]: https://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/Guardfile

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+  # Rails files
+  rails = dsl.rails(view_extensions: %w[erb haml slim])
+  dsl.watch_spec_files_for(rails.app_files)
+  dsl.watch_spec_files_for(rails.views)
+
+  watch(rails.controllers) do |m|
+    [
+      rspec.spec.call("routing/#{m[1]}_routing"),
+      rspec.spec.call("controllers/#{m[1]}_controller"),
+      rspec.spec.call("acceptance/#{m[1]}"),
+    ]
+  end
+
+  # Rails config changes
+  watch(rails.spec_helper)     { rspec.spec_dir }
+  watch(rails.routes)          { "#{rspec.spec_dir}/routing" }
+  watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }
+
+  # Capybara features specs
+  watch(rails.view_dirs)     { |m| rspec.spec.call("features/#{m[1]}") }
+  watch(rails.layouts)       { |m| rspec.spec.call("features/#{m[1]}") }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
+    Dir[File.join("**/#{m[1]}.feature")][0] || "spec/acceptance"
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Pavel Astraukh
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,102 @@
+# Twitch::Bot
+
+`twitch-bot` provides a Twitch chat client object that can be used for building Twitch chat bots.
+
+This gem is based on the `twitch-chat` gem by https://github.com/EnotPoloskun.
+
+## Installation
+
+Add this line to your application's `Gemfile`:
+
+```ruby
+gem 'twitch-bot'
+```
+
+Install all the dependencies:
+
+```
+$ bundle
+```
+
+Or install it manually via:
+
+```
+$ gem install twitch-bot
+```
+
+## Usage
+
+```ruby
+require "twitch/bot"
+
+class JoinHandler < Twitch::Bot::EventHandler
+  def call
+    client.send_message "Hi guys!"
+  end
+
+  def self.handled_events
+    [:join]
+  end
+end
+
+class SubscriptionHandler < Twitch::Bot::EventHandler
+  def call
+    client.send_message "Hi #{event.user}, thank you for your subscription"
+  end
+
+  def self.handled_events
+    [:subscription]
+  end
+end
+
+class TimeCommandHandler < Twitch::Bot::EventHandler
+  def call
+    if event.bot_command?("time")
+      client.send_message "Current time: #{Time.now.utc}"
+    end
+  end
+
+  def self.handled_events
+    [:chat_message]
+  end
+end
+
+connection = Twitch::Bot::Connection.new(
+  nickname: "test",
+  password: "secret",
+)
+
+client = Twitch::Bot::Client.new(
+  connection: connection,
+  channel: "test",
+) do
+  register_handler(JoinHandler)
+  register_handler(SubscriptionHandler)
+  register_handler(TimeCommandHandler)
+end
+
+client.run
+```
+
+## Supported event types
+
+* ``:authenticated``
+* ``:join``
+* ``:message``
+* ``:slow_mode``
+* ``:r9k_mode``
+* ``:followers_mode``
+* ``:subscribers_mode``
+* ``:subscribe``
+* ``:stop``
+* ``:not_supported``
+
+## Contributing
+
+1. Fork the repo (https://github.com/geewiz/twitch-bot/fork)
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -a`)
+4. Push the branch (`git push origin my-new-feature`)
+5. Submit a Pull Request from your Github repository
+
+Please take note of the Code Of Conduct in `CODE_OF_CONDUCT.md`.

data/Rakefile

@@ -0,0 +1,14 @@
+require "bundler/gem_tasks"
+
+task test: %i[rubocop spec]
+
+begin
+  require "rspec/core/rake_task"
+  RSpec::Core::RakeTask.new(:spec)
+  task default: :spec
+rescue LoadError
+  puts "RSpec is unavailable"
+end
+
+require "rubocop/rake_task"
+RuboCop::RakeTask.new

data/lib/twitch/bot/channel.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Twitch
+  module Bot
+    # Twitch channel management
+    class Channel
+      attr_reader :name, :moderators
+
+      def initialize(name)
+        @name = name.downcase
+        @moderators = []
+      end
+
+      def add_moderator(moderator)
+        @moderators << moderator
+      end
+
+      def remove_moderator(moderator)
+        @moderators.delete moderator
+      end
+    end
+  end
+end

data/lib/twitch/bot/client.rb

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+require "logger"
+require "socket"
+
+Thread.abort_on_exception = true
+
+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
+          @type = :stop
+        end
+      end
+
+      attr_reader :connection
+
+      def initialize(
+        connection:, output: STDOUT, channel: nil, &block
+      )
+        @connection = connection
+        @logger = Logger.new(output)
+        @channel = Twitch::Bot::Channel.new(channel) if channel
+        @messages_queue = []
+        @running = false
+        @event_handlers = {}
+
+        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
+        end
+      end
+
+      def run
+        raise "Already running" if running
+
+        @running = true
+
+        %w[TERM INT].each { |signal| trap(signal) { stop } }
+
+        connect
+        input_thread.join
+        messages_thread.join
+        logger.debug "Joined"
+      end
+
+      def join(channel)
+        @channel = Channel.new(channel)
+        send_data "JOIN ##{@channel.name}"
+      end
+
+      def part
+        send_data "PART ##{@channel.name}"
+        @channel = nil
+        @messages_queue = []
+      end
+
+      def send_message(message)
+        @messages_queue << message if @messages_queue.last != message
+      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
+
+      def stop
+        trigger StopEvent.new
+        @running = false
+        part 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.info "< #{log_data}"
+        socket.puts(data)
+      end
+
+      def join_default_channel
+        join @channel.name if @channel
+      end
+
+      def add_moderator(user)
+        channel.add_moderator(user)
+      end
+
+      def remove_moderator(user)
+        channel.remove_moderator(user)
+      end
+
+      private
+
+      attr_reader :event_handlers, :running, :input_thread, :messages_thread,
+                  :socket, :logger
+
+      def connect
+        @socket = ::TCPSocket.new(connection.hostname, connection.port)
+
+        start_input_thread
+        start_messages_thread
+        enable_twitch_capabilities
+        authenticate
+      end
+
+      def enable_twitch_capabilities
+        send_data <<~DATA
+          CAP REQ :twitch.tv/tags twitch.tv/commands twitch.tv/membership
+        DATA
+      end
+
+      def authenticate
+        send_data "PASS #{connection.password}"
+        send_data "NICK #{connection.nickname}"
+      end
+
+      def start_input_thread
+        @input_thread = Thread.start do
+          while running
+            line = read_socket
+            logger.info "> #{line}"
+            irc_message = IrcMessage.new(line)
+            trigger(Twitch::Bot::MessageParser.new(irc_message).message)
+          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
+        line
+      end
+
+      def start_messages_thread
+        @messages_thread = Thread.start do
+          while running
+            sleep message_delay
+
+            # TODO: Replace with core Queue
+            if (message = @messages_queue.pop)
+              send_data "PRIVMSG ##{@channel.name} :#{message}"
+            end
+          end
+
+          logger.debug "End of messages thread"
+        end
+      end
+
+      def execute_initialize_block(block)
+        if block.arity == 1
+          block.call self
+        else
+          instance_eval(&block)
+        end
+      end
+
+      def register_default_handlers
+        register_handler(Twitch::Bot::Client::PingHandler)
+        register_handler(Twitch::Bot::Client::AuthenticatedHandler)
+        register_handler(Twitch::Bot::Client::ModeHandler)
+      end
+    end
+  end
+end

data/lib/twitch/bot/connection.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Twitch
+  module Bot
+    # This class stores the connection details for the client.
+    class Connection
+      attr_reader :nickname, :password, :hostname, :port
+
+      def initialize(
+        nickname:, password:, hostname: "irc.chat.twitch.tv", port: "6667"
+      )
+        @nickname = nickname
+        @password = password
+        @hostname = hostname
+        @port = port
+      end
+    end
+  end
+end

data/lib/twitch/bot/event.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Twitch
+  module Bot
+    # Represent a generic Twitch chat event/message
+    class Event
+      attr_reader :type
+
+      def initialize(type: :unknown)
+        @type = type
+      end
+    end
+  end
+end

data/lib/twitch/bot/event_handler.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Twitch
+  module Bot
+    # Handles a message of a specific type
+    class EventHandler
+      attr_reader :event, :client
+
+      def initialize(event:, client:)
+        @event = event
+        @client = client
+      end
+
+      #
+      # Handle the event
+      #
+      # @return void
+      #
+      def call
+        raise "Unhandled #{event.type}"
+      end
+
+      #
+      # Return a list of event types this handler can handle
+      #
+      # @return [Array] event type list
+      #
+      def self.handled_events
+        []
+      end
+    end
+  end
+end