imouto 1.0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 40af6dcddca1548d72857fde8fc7fef2f492f764
+  data.tar.gz: b01aef77249fdb1da5f6c92cf0f050450a575f19
+SHA512:
+  metadata.gz: c2225f2f2ae6773882ce15e17f8f21e58eb1242f45d65bbb36d98934f35cf103312c2a9bb077ff4792128deecbfb6d3705640c1a34904c8a9ecae47906acfffa
+  data.tar.gz: 9c177a5422eb77ac78a42d5270144309380fd4840bf06eb1775db5ecf76fb149aeccc07ef7d40536c0b29671a33dda5b0ae4612d48281fe63ac6e4097199bbcf

data/lib/imouto.rb

@@ -0,0 +1,99 @@
+require_relative 'irc'
+require_relative 'ratelimited_queue'
+
+module Imouto
+
+  # IRC-PRIVMSG, passed to matchers.
+  Message = Struct.new(
+    # PRIVMSG as string.
+    :message,
+    # Captures specified in matcher-regex
+    :captures,
+    # Raw MatchData
+    :raw
+  )
+
+  ImoutoConfig = Struct.new(
+    :loggers,
+    :message_interval_size,
+    :messages_per_interval
+  )
+
+  class Bot
+    attr_reader :matchers, :irc, :reply_queue
+
+    def initialize(irc, conf)
+      imouto_config = ImoutoConfig.new
+      conf.each { |k, v| imouto_config[k] = v; }
+      @loggers = imouto_config.loggers || [->(msg) { p msg }]
+      @matchers = {}
+      @irc = irc
+      @reply_queue = Imouto::RatelimitedQueue.new(
+        imouto_config.messages_per_interval || 3,
+        imouto_config.message_interval_size || 4)
+    end
+
+    # Starts the bot, spawning a read- and a write-thread
+    def start
+      read_thread = Thread.new { read(@irc) }
+      write_thread = Thread.new { dequeue_replies }
+      read_thread.join
+      write_thread.join
+    end
+
+    # Read from the IRC-connection until it closes.
+    def read(irc_con = @irc)
+      irc_con.start.read { |msg, matchers = @matchers|
+        matchers.keys.each { |regex|
+          msg[:message] =~ regex && reply(msg, matchers[regex], regex.match(msg[:message]))
+        }
+      }
+    end
+
+    # Reply to a PRIVMSG
+    def reply(msg, matcher, matches)
+      log("[Executing Matcher] #{msg[:message]}")
+      m = Message.new(msg[:message], matches, msg)
+      begin
+        reply = Thread.new { matcher.call(m) }.value
+      rescue StandardError => e
+        log("[Matcher Exception] #{e}")
+      end
+      reply_to = msg[:target].start_with?('#') ? msg[:target] : msg[:nick]
+      queue_reply(reply_to, reply)
+    end
+
+    # Write replies to the IRC-connection
+    def dequeue_replies(irc_con = @irc)
+      @reply_queue.dequeue { |reply, irc = irc_con|
+        log("[->] #{reply['target']}: #{reply['reply']}")
+        irc.privmsg(reply['target'], reply['reply'])
+      }
+    end
+
+    # Enqueues a reply, to be sent.
+    # You can also directly send messages by using @irc.privmsg
+    # this however bypasses rate limiting and might get you kicked.
+    def queue_reply(target, reply)
+      @reply_queue.enqueue('target' => target, 'reply' => reply)
+    end
+
+    # Calls every logger with a message.
+    def log(msg)
+      @loggers.each { |l| l.call(msg) }
+    end
+
+    # Registers a matcher to respond to PRIVMSGs that match a certain regex.
+    def register_matcher(regex, matcher)
+      return false unless matcher.respond_to? 'call'
+      @matchers[regex] = matcher
+      log("[Registered Matcher] #{regex}")
+    end
+
+    # Consumes a regex, and removes the matcher that was registered with it.
+    def unregister_matcher(regex)
+      @matchers.delete(regex)
+      log("[Removed Matcher] #{regex}")
+    end
+  end
+end

data/lib/irc.rb

@@ -0,0 +1,111 @@
+require 'timeout'
+require 'net/protocol'
+require_relative 'irc_commands'
+
+module Imouto
+  Connection = Struct.new(
+    :server,
+    :port,
+    :channels,
+    :connect_timeout,
+    :read_timeout
+  )
+
+  User = Struct.new(
+    :nick,
+    :username,
+    :realname,
+    :password
+  )
+
+  class Enum
+    attr_reader :options, :selected
+
+    def initialize(options, selected)
+      raise ArgumentError, "Expected argument options to respond to method 'at'" unless options.respond_to? 'at'
+      @options = options
+      @selected = options.first
+      set selected
+    end
+
+    def set(value)
+      return @selected unless @options.include? value
+      @selected = value
+    end
+  end
+
+  class Irc
+    include IrcCommands
+
+    attr_reader :connection, :user, :connection_state
+
+
+    def initialize(connection, user)
+      @connection = Connection.new
+      connection.each { |k, v| @connection[k] = v; }
+      @user = User.new
+      user.each { |k, v| @user[k] = v; }
+      @connection_state = Enum.new([:not_connected, :connecting, :connected, :failed], :not_connected)
+      self
+    end
+
+    # Stuff to do when the connection is successfully established
+    def setup
+      join @connection.channels
+      self
+    end
+
+    # see irc_commands.rb
+    def raw(msg)
+      @socket.puts msg
+    end
+
+    # Starts an IRC-connection. Chainable,-
+    # you probably want to do irc.start.read {|msg| ...}
+    def start
+      begin
+        Timeout.timeout(@connection.connect_timeout) {
+          @socket = TCPSocket.new(@connection.server, @connection.port)
+          raw "PASS #{@user.password}"
+          raw "NICK #{@user.nick}"
+          raw "USER #{@user.username} 0 * :#{@user.realname}"
+        }
+      rescue Timeout::Error
+        @connection_state.set(:failed)
+        puts 'Timeout! Aborting.'
+        return false
+      rescue SocketError => e
+        @connection_state.set(:failed)
+        puts "Network error: #{e}"
+        return false
+      rescue => e
+        @connection_state.set(:failed)
+        puts "General exception: #{e}"
+        return false
+      end
+      @connection_state.set(:connecting)
+      self
+    end
+
+    # Yields PRIVMSGs and handles PINGs as well as setup operations
+    def read
+      until @socket.eof?
+        msg = @socket.gets
+        if msg.start_with? 'PING'
+          raw "PONG #{msg[6..-1]}"
+          next
+        end
+        if  msg.include? 'PRIVMSG'
+          m = msg.chomp.match(/:(?<nick>.*)!(?<mask>.*) PRIVMSG (?<target>.*) :(?<message>.*)$/)
+          yield m
+        end
+        if (@connection_state.selected == :connecting) && (msg =~ /:(.*) 376 #{@user.nick} :(.*)$/)
+          setup
+          @connection_state.set(:connected)
+          next
+        end
+      end
+    end
+
+  end
+end

data/lib/irc_commands.rb

@@ -0,0 +1,50 @@
+module IrcCommands
+  # Overwrite raw() to send to your socket wherever you include this
+  def raw(string)
+    puts string
+  end
+
+  def mode(nick, state, mode)
+    return false unless %w(a i w r o O s).include? mode
+    raw "MODE #{nick} #{state}#{mode}"
+  end
+
+  def quit(msg = '')
+    raw "QUIT :#{msg}"
+  end
+
+  def join(channels)
+    channels.respond_to?('join') && channels = channels.join(',')
+    raw "JOIN #{channels}"
+  end
+
+  def part(channels, msg = '')
+    channels.respond_to?('join') && channels = channels.join(',')
+    raw "PART #{channels} :#{msg}"
+  end
+
+  def channel_mode(channel, state, mode, modeparams = '')
+    return false unless %w(O o v a i m n q p s r t k l b e I).include? mode
+    raw "MODE #{channel} #{state} #{mode} #{modeparams}"
+  end
+
+  def topic(channel, topic)
+    raw "TOPIC #{channel} :#{topic}"
+  end
+
+  def invite(nick, channel)
+    raw "INVITE #{nick} #{channel}"
+  end
+
+  def kick(channel, user, reason = '')
+    raw "KICK #{channel} #{user} :#{reason}"
+  end
+
+  def privmsg(target, msg)
+    raw "PRIVMSG #{target} :#{msg}"
+  end
+
+  def notice(target, msg)
+    raw "NOTICE #{target} :#{msg}"
+  end
+end

data/lib/ratelimited_queue.rb

@@ -0,0 +1,35 @@
+module Imouto
+  class RatelimitedQueue
+    attr_reader :messages_per_interval, :interval_in_seconds
+
+    def initialize(messages_per_interval, interval_in_seconds)
+      @messages_per_interval = messages_per_interval
+      @interval_in_seconds = interval_in_seconds
+      @messages_this_interval = 0
+      @current_interval = Time.now
+      @items = []
+    end
+
+    def enqueue(item)
+      @items << item
+    end
+
+    def dequeue
+      loop {
+        if @items.empty?
+          sleep 1
+          next
+        end
+        interval = Time.now
+        if interval > @current_interval + @interval_in_seconds
+          @current_interval = interval
+          @messages_this_interval = 0
+        end
+        if @messages_this_interval < @messages_per_interval
+          @messages_this_interval += 1
+          yield @items.shift
+        end
+      }
+    end
+  end
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: imouto
+version: !ruby/object:Gem::Version
+  version: 1.0.6
+platform: ruby
+authors:
+- zwwwdr
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-04 00:00:00.000000000 Z
+dependencies: []
+description: A really basic & lightweight IRC-client-lib. Mix with a few lambdas for
+  instant bot.
+email: zwdr@cock.li
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/imouto.rb
+- lib/irc.rb
+- lib/irc_commands.rb
+- lib/ratelimited_queue.rb
+homepage: https://github.com/2-3/imouto
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Basic IRC bot library, without frills
+test_files: []