chatx 0.0.0.pre.pre3

data/lib/chatx/hooks.rb

@@ -0,0 +1,111 @@
+class ChatBot
+  # The immediate exit point when a message is recieved from a websocket. It
+  # grabs the relevant hooks, creates the event, and passes the event to the
+  # hooks.
+  #
+  # It also spawns a new thread for every hook. This could lead to errors later,
+  # but it prevents 409 errors which shut the bot up for a while.
+  #
+  # @note This method is strictly internal.
+  # @param data [Hash] It's the JSON passed by the websocket
+  def handle(data, server: @default_server)
+    data.each do |room, evt|
+      next if evt.keys.first != 'e'
+      evt['e'].each do |e|
+        event_type = e['event_type'].to_i - 1
+        room_id = room[1..-1].to_i
+        event = ChatX::Event.new e, server, self
+        @ws_json_logger.info "#{event.type_long}: #{event.hash} #{event.inspect}"
+        @ws_json_logger.info "Currently in rooms #{@rooms.keys} / #{current_rooms}"
+        break if @rooms[room_id].nil?
+        @rooms[room_id.to_i][:events].push(event)
+        next if @hooks[event_type.to_i].nil?
+        @hooks[event_type.to_i].each do |rm_id, hook|
+          Thread.new do
+            @hook.current_room = room_id
+            hook.call(event) if rm_id == room_id || rm_id == '*'
+          end
+        end
+      end
+    end
+  end
+
+  # A convinant way to hook into an event.
+  # @param room_id [#to_i] The ID of th room to listen in.
+  # @param event [String] The [EVENT_SHORTHAND] for the event ID.
+  # @param action [Proc] This is a block which will run when the hook
+  #   is triggered. It is passed one parameter, which is the event.
+  #   It is important to note that it will NOT be passed an {Event},
+  #   rather, it will be passed a sub event designated in {Event::EVENT_CLASSES}.
+  def add_hook(room_id, event, &action)
+    @hooks[EVENT_SHORTHAND.index(event)] ||= []
+    @hooks[EVENT_SHORTHAND.index(event)].push [room_id, action]
+  end
+
+  # A simpler syntax for creating {add_hook} to the "Message Posted" event.
+  # @param room_id [#to_i] The room to listen in
+  # @see #add_hook
+  def on_message(room_id)
+    add_hook(room_id, 'Message Posted') { |e| yield(e.hash['content']) }
+  end
+
+  # This opens up the DSL created by {Hook}.
+  def gen_hooks(&block)
+    @hook ||= Hook.new(self)
+    @hook.instance_eval(&block)
+  end
+end
+
+class Hook
+  attr_reader :bot
+  attr_accessor :current_room
+
+  def initialize(bot)
+    @bot = bot
+  end
+
+  def say(message, room_id = @current_room)
+    @bot.say(message, room_id)
+  end
+
+  def room(room_id, &block)
+    room = Room.new(room_id, self)
+    room.instance_eval(&block)
+  end
+
+  def on(event, &block)
+    @bot.hooks[EVENT_SHORTHAND.index(event)] ||= []
+    @bot.hooks[EVENT_SHORTHAND.index(event)].push ['*', block]
+  end
+
+  def command(prefix, &block)
+    on "message" do |e|
+      msg = HTMLEntities.new.decode(e.content)
+      if msg.downcase == prefix || msg.downcase.start_with?("#{prefix} ")
+        args = msg.scan(%r{\"(.*)\"|\'(.*)\'|([^\s]*)}).flatten.reject { |a| a.to_s.empty? }[1..-1]
+        block.call(*args)
+      end
+    end
+  end
+
+  class Room < Hook
+    def initialize(room_id, hook)
+      @hook = hook
+      @bot = hook.bot
+      @room_id = room_id
+    end
+
+    def say(msg)
+      @bot.say(msg, @room_id)
+    end
+
+    def reply_to(msg, reply)
+      msg.reply(@bot, reply)
+    end
+
+    def on(event, &block)
+      @bot.hooks[EVENT_SHORTHAND.index(event)] ||= []
+      @bot.hooks[EVENT_SHORTHAND.index(event)].push [@room_id, block]
+    end
+  end
+end

data/lib/chatx/models/helpers.rb

@@ -0,0 +1,36 @@
+module ChatX
+  class Helpers
+    @cache = {}
+
+    def self.symbolize_hash_keys(hash)
+      hash.each_key do |key|
+        # rubocop:disable Lint/RescueWithoutErrorClass
+        hash[(begin
+                key.to_sym
+              rescue
+                key
+              end) || key] = hash.delete(key)
+        # rubocop:enable: Lint/RescueWithoutErrorClass
+      end
+      hash
+    end
+
+    def self.cached(key, scope = nil)
+      @cache ||= {}
+      if !scope.nil?
+        @cache[scope] ||= {}
+        @cache[scope][key] = yield if @cache[scope][key].nil?
+        @cache[scope][key]
+      else
+        @cache[key] = yield if @cache[key].nil?
+        @cache[key]
+      end
+    end
+  end
+
+  class InitializationDataException < RuntimeError
+    def initialize(msg)
+      super(msg)
+    end
+  end
+end

data/lib/chatx/models/message.rb

@@ -0,0 +1,68 @@
+require 'date'
+require_relative 'helpers'
+require_relative 'room'
+require_relative 'user'
+
+module ChatX
+  class Message
+    attr_reader :server, :timestamp, :content, :room, :user, :id, :parent_id
+
+    def initialize(server, **opts)
+      if opts.values_at(:time_stamp, :content, :room_id, :user_id, :message_id).any?(&:nil?)
+        raise ChatX::InitializationDataException, 'Got nil for an expected message property'
+      end
+
+      @server = server
+
+      @id = opts[:message_id]
+      @timestamp = Time.at(opts[:time_stamp]).utc.to_datetime
+      @content = opts[:content]
+      @room = ChatX::Helpers.cached opts[:room_id].to_i, :rooms do
+        ChatX::Room.new server, room_id: opts[:room_id].to_i
+      end
+      @user = ChatX::Helpers.cached opts[:user_id].to_i, :users do
+        ChatX::User.new server, user_id: opts[:user_id].to_i
+      end
+
+      @parent_id = opts[:parent_id]
+    end
+
+    def reply(bot, content)
+      bot.say ":#{id} #{content}", @room.id, server: @server
+    end
+
+    def reply?
+      @content =~ /^:\d+\s/
+    end
+
+    def pings
+      @pings = @content.scan(/@(\w+)/).flatten if @pings.nil?
+      @pings
+    end
+
+    def pinged?(username)
+      @pings.map(&:downcase).map { |x| username.downcase.start_with? x }.any?
+    end
+
+    %i[
+      toggle_star
+      star_count
+      star
+      unstar
+      starred?
+      cancel_stars
+      delete
+      edit
+      toggle_pin
+      pin
+      unpin
+      pinned?
+    ].each do |name|
+      define_method(name) { |bot| bot.send(name, @id, @server) }
+    end
+
+    def self.from_hash(server, hash)
+      new server, **ChatX::Helpers.symbolize_hash_keys(hash)
+    end
+  end
+end

data/lib/chatx/models/room.rb

@@ -0,0 +1,56 @@
+require_relative 'helpers'
+
+module ChatX
+  class Room
+    attr_reader :users, :name, :id, :server, :stars, :owners, :description
+
+    def initialize(server, **opts)
+      if opts.values_at(:room_id).any?(&:nil?)
+        raise ArgumentError, 'Got nil for an expected room property'
+      end
+
+      @server = server
+
+      @id = opts[:room_id]
+      track_users            if opts[:track_users]
+      track_starred_messages if opts[:track_starred_messages]
+      metadata               if opts[:metadata]
+    end
+
+    private
+
+    def track_users
+      room_page = Nokogiri::HTML open("https://chat.#{@server}.com/rooms/#{@id}")
+      @users = room_page.css('#room-usercards-container').children.map do |e|
+        e = e.css('.user-header > a').attr('href').split('/')
+        User.new(server,
+                 user_name: e[-1],
+                 user_id:   e[-2])
+      end
+    end
+
+    def track_starred_messages
+      star_page = Nokogiri::HTML open("https://chat.#{@server}.com/rooms/starred/#{@id}")
+      @stars = star_page.css('entry').map do |e|
+        Message.new @server,
+                    time_stamp:  Time.parse(e.css('published').first.text).utc.to_i,
+                    content:    e.css('summary').first.text,
+                    user_id:    e.css('author uri').first.text.split('/').last,
+                    message_id: e.css('id').first.text.split('-').last,
+                    room_id:    @id
+      end
+    end
+
+    def metadata
+      metadata_card = Nokogiri::HTML(open("https://chat.#{@server}.com/rooms/info/#{@id}")).css('.roomcard-xxl')
+      @name = metadata_card.css('h1').first.text
+      @description = metadata_card.css('p').first.text
+
+      owner_cards = Nokogiri::HTML(open("https://chat.#{@server}.com/rooms/info/#{@id}")).css('.room-ownercards')
+      @owners = owner_cards.each do |e|
+        id, name = e.css('a:first-child').attr('href').split('/')
+        User.new(@server, user_id: id, user_name: name)
+      end
+    end
+  end
+end

data/lib/chatx/models/user.rb

@@ -0,0 +1,51 @@
+require_relative 'helpers'
+
+module ChatX
+  class User
+    attr_reader :owns_rooms, :in_rooms, :description, :id, :username, :server
+
+    def initialize(server, **opts)
+      if opts.values_at(:user_id).any?(&:nil?)
+        raise ArgumentError, 'Got nil for an expected user property'
+      end
+
+      @server = server
+      @id = opts[:user_id]
+
+      metadata
+    end
+
+    private
+
+    def metadata
+      metadata_page = Nokogiri::HTML open("https://chat.#{@server}.com/users/#{@id}")
+      @username = metadata_page.css('.usercard-xxl .user-status').first.text
+      @description = metadata_page.css('.user-stats tr:nth-child(4) td:last-child').text
+
+      in_room_cards = metadata_page.css('#user-roomcards-container').children
+      @in_rooms = if !in_room_cards.nil?
+                    in_room_cards.reject { |e| e.is_a? Nokogiri::XML::Text }.map do |e|
+                      rid = e.attr('id').split('-').last.to_i
+                      ChatX::Helpers.cached rid, :rooms do
+                        Room.new @server, room_id: rid
+                      end
+                    end
+                  else
+                    []
+                  end
+
+      owns_room_cards = metadata_page.css('#user-owningcards').children[-1..1]
+      @owns_rooms = if !owns_room_cards.nil?
+                      owns_room_cards.reject { |e| e.is_a? Nokogiri::XML::Text }.map do |e|
+                        puts e
+                        rid = e.attr('id').split('-').last.to_i
+                        ChatX::Helpers.cached rid, :rooms do
+                          Room.new @server, room_id: rid
+                        end
+                      end
+                    else
+                      []
+                    end
+    end
+  end
+end

data/lib/chatx/polling.rb

@@ -0,0 +1,46 @@
+class AnonClient
+  attr_accessor :rooms
+  attr_reader :server
+  def initialize(bot, server, room_id, poll_frequency: 2)
+    @poll_frequency = poll_frequency
+    @bot = bot
+    @dead = false
+    @server = server
+    join_room room_id
+    start_loop
+  end
+
+  def join_room(room_id)
+    @fkey = Nokogiri::HTML(open("https://chat.#{server}.com/rooms/#{room_id}").read).search("//input[@name='fkey']").attribute("value")
+    events_json = Net::HTTP.post_form(URI("https://chat.#{@server}.com/chats/#{room_id}/events"),
+                                      fkey: @fkey,
+                                      since: 0,
+                                      mode: "Messages",
+                                      msgCount: 100).body
+
+    events = JSON.parse(events_json)["events"]
+    last_event_time = events.max_by { |event| event['time_stamp'] }['time_stamp']
+    @rooms = {"r#{room_id}" => last_event_time}
+  end
+
+  def kill
+    @dead = true
+    @thread.join
+  end
+
+  private
+
+  def start_loop
+    @thread = Thread.new do
+      until @dead
+        response_json = Net::HTTP.post_form(URI("https://chat.#{@server}.com/events"), {fkey: @fkey}.merge(@rooms))
+        response = JSON.parse(response_json.body)
+        response.each do |room, data|
+          @rooms[room] = data["t"] unless data["t"].nil?
+        end
+        @bot.handle(response)
+        sleep @poll_frequency
+      end
+    end
+  end
+end

data/lib/chatx/version.rb

@@ -0,0 +1,3 @@
+class ChatBot
+  VERSION = '0.0.0-pre3'.freeze
+end

data/lib/chatx/websocket.rb

@@ -0,0 +1,76 @@
+class WSClient
+  attr_reader :url, :thread, :driver, :in_rooms
+
+  # Opens a websocket. This was really annoying. To open a websocket, you've got
+  # to grab a weird uri (see {#join_room}) and pass some cookies and set the origin
+  # header. Anywho, it opens a new socket in a new thread.
+  # @note This method is internal. Do not use.
+  # @param uri [String] See {#join_room}
+  # @param cookies [String] See {#join_room}
+  # @param server [String] The chat server to use.
+  def initialize(url, cookies, bot, server)
+    bot.logger.info "Opening on #{url}"
+    @logger   = Logger.new 'websocket_raw.log'
+    @url      = url
+    @bot      = bot
+    @in_rooms = {rooms: [], last_updated: Time.now}
+    @uri      = URI.parse(url)
+    @driver   = WebSocket::Driver.client(self)
+    @tcp      = TCPSocket.new(@uri.host, 80) # (@uri.scheme == "wss" || @uri.scheme == "ws" ? 80 : 443))
+    @restart  = true
+    @driver.add_extension(PermessageDeflate)
+    @driver.set_header("Cookie", cookies)
+    @driver.set_header("Origin", "https://chat.#{server}.com")
+
+    @driver.on :connect, ->(_e) {}
+
+    @driver.on :open, ->(_e) { @bot.logger.info "WebSocket is open!" }
+
+    @driver.on :message do |e|
+      @logger.info "Read:  #{e.data}"
+      @bot.handle(JSON.parse(e.data))
+      @in_rooms = {rooms: JSON.parse(e.data).keys.map { |k| k[1..-1].to_i }, last_updated: Time.now}
+    end
+
+    @driver.on :close, ->(_e) do
+      @bot.logger.error "The websocket is closing."
+      if @restart
+        @bot.logger.info "Attempting to reopen websocket..."
+        @driver.start
+      end
+    end
+
+    @driver.on :error, ->(e) { @bot.logger.error e }
+
+    @driver.start
+
+    @thread = Thread.new do
+      trap("SIGINT") do
+        @restart = false
+        close
+        Thread.exit
+      end
+      begin
+        loop { @driver.parse(@tcp.recv(1)) }
+      rescue IOError, SystemCallError => e
+        @bot.logger.debug "Recieved #{e} closing TCP socket. You shouldn't be worried :)"
+      end
+    end
+  end
+
+  def send(message)
+    @logger.info "Write: #{message}"
+    @driver.text(message)
+  end
+
+  def write(data)
+    @tcp.write(data)
+  end
+
+  def close
+    @driver.close
+    @tcp.shutdown
+  rescue IOError, Errno::ENOTCONN => e
+    @bot.logger.error "Recieved #{e.class} trying to close websocket. Ignoring..."
+  end
+end