chatx 0.0.0.pre.pre3

data/lib/chatx.rb

@@ -0,0 +1,271 @@
+require "mechanize"
+require "nokogiri"
+require "websocket/driver"
+require "json"
+require "permessage_deflate"
+require "open-uri"
+require_relative "chatx/events"
+require_relative "chatx/auth"
+require_relative "chatx/websocket"
+require_relative "chatx/hooks"
+require_relative "chatx/polling"
+
+require "thwait"
+
+Thread.abort_on_exception = true
+
+class ChatBot
+  # @!attribute [r] rooms
+  #   @return [Hash<Hash<Array>>] a hash of the rooms. Each key is a room ID, and
+  #     each value is futher hash with an :events key which contains an array
+  #     of {Event}s from that room.
+  # @!attribute [r] websocket
+  #   @return [Hash<room_id, Thread>] a hash of websockets. Each key is a room ID and
+  #     each value is a websocket thread. Each websocket gets it's own thead because
+  #     EventMachine blocks the main thread when I run it there.
+  # @!attribute [rw] default_server
+  #   @return [String] The default server to connect to. It's good to
+  #     pass this to the default_server keyword argument of the {initialize} method
+  #     if you're only sticking to one server. Otherwise, with every {#say}
+  #     you'll have to specify the server. This defaults to stackexchange. The options for
+  #     this are "meta.stackexchange", "stackexchange", and "stackoverflow". The rest of
+  #     the URL is managed internally.
+  # @!attribute [rw] hooks
+  #   @return [Array] An array of the {Hook}s for the bot.
+  attr_reader :rooms, :websockets, :logger
+  attr_accessor :default_server, :hooks
+
+  # Creates a bot.
+  #
+  # These must be stack exchange openid credentials, and the user
+  # must have spoken in a room on that server first.
+  #
+  # For further details on authentication, see #authenticate
+  #
+  # @param [String] email The Stack Exchange OpenID email
+  # @param [String] password The Stack Exchange OpenID password
+  # @return [ChatBot] A new bot instance. Not sure what happens if
+  #   you try and run more than one at a time...
+  def initialize(email, password, **opts)
+    opts[:default_server] ||= 'stackexchange'
+    opts[:log_location] ||= STDOUT
+    opts[:log_level] ||= Logger::DEBUG
+
+    @logger = Logger.new opts[:log_location]
+    @logger.level = opts[:log_level]
+
+    @ws_json_logger = Logger.new 'websockets_json.log'
+
+    @email = email
+    @password = password
+    @agent = Mechanize.new
+    @rooms = {} # room_id => {events}
+    @default_server = opts[:default_server]
+    @hooks = {}
+    @websockets = {}
+    at_exit { rejoin }
+  end
+
+  # Logs the bot into the three SE chat servers.
+  #
+  # @return [Boolean] A bool indicating the result of authentication: true if all three
+  # servers were authenticated successfully, false otherwise.
+  def login(servers = @default_server)
+    servers = [servers] unless servers.is_a? Array
+    authenticate(servers)
+  end
+
+  # Attempts to join a room, and for every room joined opens a websocket.
+  # Websockets seem to be the way to show your presence in a room. It's weird
+  # that way.
+  #
+  # Each websocket is added to the @websockets instance variable which can be
+  # read but not written to.
+  #
+  # @param room_id [#to_i] A valid room ID on the server designated by the
+  #   server param.
+  # @keyword server [String] A string referring to the relevant server. The
+  #   default value is set by the @default_server instance variable.
+  # @return [Hash] The hash of currently active websockets.
+  def join_room(room_id, server: @default_server)
+    @logger.info "Joining #{room_id}"
+
+    fkey = get_fkey(server, "rooms/#{room_id}")
+
+    @agent.get("https://chat.#{server}.com/rooms/#{room_id}", fkey: fkey)
+
+    events_json = @agent.post("https://chat.#{server}.com/chats/#{room_id}/events",
+                              fkey: fkey,
+                              since: 0,
+                              mode: "Messages",
+                              msgCount: 100).body
+
+    events = JSON.parse(events_json)["events"]
+
+    @logger.info "Retrieved events (length #{events.length})"
+
+    ws_auth_data = @agent.post("https://chat.#{server}.com/ws-auth",
+                               roomid: room_id,
+                               fkey: fkey)
+
+    @logger.info "Began room auth for room id: #{room_id}"
+
+    @rooms[room_id.to_i] = {}
+    @rooms[room_id.to_i][:events] = events.map do |e|
+      begin
+        ChatX::Event.new e, server, self
+      rescue ChatX::InitializationDataException => e
+        @logger.warn "Caught InitializationDataException during events population (#{e}); skipping event"
+        nil
+      end
+    end.compact
+
+    @logger.info "Rooms: #{@rooms.keys}"
+
+    unless @websockets[server].nil?
+      @websockets[server].driver.close
+      @logger.info "Websocket #{@websockets[server]} already open; clearing."
+      @websockets[server] = nil
+    end
+    ws_uri = JSON.parse(ws_auth_data.body)["url"]
+    last_event_time = events.max_by { |event| event['time_stamp'] }['time_stamp']
+    cookies = (@agent.cookies.map { |cookie| "#{cookie.name}=#{cookie.value}" if cookie.domain == "chat.#{server}.com" || cookie.domain == "#{server}.com" } - [nil]).join("; ")
+    @websockets[server] = WSClient.new("#{ws_uri}?l=#{last_event_time}", cookies, self, server)
+    @logger.info "New websocket open (#{@websockets[server]}"
+  end
+
+  # Leaves the room. Not much else to say...
+  # @param room_id [#to_i] The ID of the room to leave
+  # @keyword server [String] The chat server that room is on.
+  # @return A meaningless value
+  def leave_room(room_id, server: @default_server)
+    fkey = get_fkey("stackexchange", "/rooms/#{room_id}")
+    @rooms.delete(room_id) unless @rooms[room_id].nil?
+    @agent.post("https://chat.#{server}.com/chats/leave/#{room_id}", fkey: fkey, quiet: "true")
+  end
+
+  # Speaks in a room! Not much to say here, but much to say in the room
+  # that is passed!
+  #
+  # If you're trying to reply to a message, please use the {Message#reply}
+  # method.
+  # @param room_id [#to_i] The ID of the room to be spoken in
+  # @param content [String] The text of message to send
+  # @keyword server [String]  The server to send the messon on.
+  # @return A meaningless value
+  def say(content, room_id, server: @default_server)
+    fkey = get_fkey(server, "/rooms/#{room_id}")
+    @logger.warn "Message too long, truncating each line to 500 chars: #{content}" if content.to_s.split("\n").any? { |line| line.length > 500 }
+    if content.to_s.empty?
+      @logger.warn "Message is empty, not posting: '#{content}'"
+      return
+    end
+    begin
+      resp = @agent.post("https://chat.#{server}.com/chats/#{room_id}/messages/new", fkey: fkey, text: content.to_s.split("\n").map { |line| line[0...500] }.join("\n"))
+    rescue Mechanize::ResponseCodeError
+      @logger.error "Posting message to room #{room_id} failed. Retrying... #{content.to_s.split("\n").map { |line| line[0...500] }.join("\n")}"
+      sleep 0.3 # A magic number I just chose for no reason
+      retry
+    end
+    return JSON.parse(resp.content)["id"].to_i
+  end
+
+  def toggle_star(message_id, server: @default_server)
+    fkey = get_fkey("stackexchange")
+    @agent.post("https://chat.#{server}.com/messages/#{message_id}/star", fkey: fkey)
+  end
+
+  def star_count(message_id, server: @default_server)
+    page = @agent.get("https://chat.#{server}.com/transcript/message/#{message_id}")
+    page.css("#message-#{message_id} .flash .star .times")[0].content.to_i
+  end
+
+  def star(message_id, server: @default_server)
+    fkey = get_fkey("stackexchange")
+    @agent.post("https://chat.#{server}.com/messages/#{message_id}/star", fkey: fkey) unless starred?(message_id)
+  end
+
+  def unstar(message_id, server: @default_server)
+    fkey = get_fkey("stackexchange")
+    @agent.post("https://chat.#{server}.com/messages/#{message_id}/star", fkey: fkey) if starred?(message_id)
+  end
+
+  def starred?(message_id, server: @default_server)
+    page = @agent.get("https://chat.#{server}.com/transcript/message/#{message_id}")
+    return false if page.css("#message-#{message_id} .flash .stars")[0].nil?
+    page.css("#message-#{message_id} .flash .stars")[0].attr("class").include?("user-star")
+  end
+
+  def cancel_stars(message_id, server: @default_server)
+    fkey = get_fkey("stackexchange")
+    @agent.post("https://chat.#{server}.com/messages/#{message_id}/unstar", fkey: fkey)
+  end
+
+  def delete(message_id, server: @default_server)
+    fkey = get_fkey("stackexchange")
+    @agent.post("https://chat.#{server}.com/messages/#{message_id}/delete", fkey: fkey)
+  end
+
+  def edit(message_id, new_message, server: @default_server)
+    fkey = get_fkey("stackexchange")
+    @agent.post("https://chat.#{server}.com/messages/#{message_id}", fkey: fkey, text: new_message)
+  end
+
+  def toggle_pin(message_id, server: @default_server)
+    fkey = get_fkey("stackexchange")
+    @agent.post("https://chat.#{server}.com/messages/#{message_id}/owner-star", fkey: fkey)
+  end
+
+  def pin(message_id, server: @default_server)
+    fkey = get_fkey("stackexchange")
+    @agent.post("https://chat.#{server}.com/messages/#{message_id}/owner-star", fkey: fkey)
+  end
+
+  def unpin(message_id, server: @default_server)
+    fkey = get_fkey("stackexchange")
+    @agent.post("https://chat.#{server}.com/messages/#{message_id}/owner-star", fkey: fkey)
+  end
+
+  def pinned?(message_id, server: @default_server)
+    page = @agent.get("https://chat.#{server}.com/transcript/message/#{message_id}")
+    return false if page.css("#message-#{message_id} .flash .stars")[0].nil?
+    page.css("#message-#{message_id} .flash .stars")[0].attr("class").include?("owner-star")
+  end
+
+  # Kills all active websockets for the bot.
+  def kill
+    @websockets.values.each(&:close)
+  end
+
+  def rejoin
+    ThreadsWait.all_waits @websockets.values.map(&:thread)
+    leave_all_rooms
+  end
+
+  def stop
+    leave_all_rooms
+    @websockets.values.map(&:thread).each(&:kill)
+  end
+
+  def leave_all_rooms
+    @rooms.each_key do |room_id|
+      leave_room(room_id)
+    end
+  end
+
+  def current_rooms
+    @websockets.map do |server, ws|
+      [server, ws.in_rooms[:rooms]]
+    end.to_h
+  end
+
+  private
+
+  def get_fkey(server, uri = "")
+    @agent.get("https://chat.#{server}.com/#{uri}").search("//input[@name='fkey']").attribute("value")
+  rescue Mechanize::ResponseCodeError
+    @logger.error "Getting fkey failed for uri https://chat.#{server}.com/#{uri}. Retrying..."
+    sleep 1 # A magic number I just chose for no reason
+    retry
+  end
+end

data/lib/chatx/auth.rb

@@ -0,0 +1,38 @@
+class ChatBot
+  def authenticate(sites = ["stackexchange"])
+    sites = [sites] unless sites.is_a?(Array)
+
+    openid = @agent.get "https://openid.stackexchange.com/account/login"
+    fkey_input = openid.search "//input[@name='fkey']"
+    fkey = fkey_input.empty? ? "" : fkey_input.attribute("value")
+
+    @agent.post("https://openid.stackexchange.com/account/login/submit",
+                fkey:     fkey,
+                email:    @email,
+                password: @password)
+
+    auth_results = sites.map { |s| site_auth(s) }
+    failed = auth_results.any?(&:!)
+    !failed
+  end
+
+  def site_auth(site)
+    # Get fkey
+    login_page = @agent.get "https://#{site}.com/users/login"
+    fkey_input = login_page.search "//input[@name='fkey']"
+    fkey = fkey_input.attribute('value')
+
+    @agent.post("https://#{site}.com/users/authenticate",
+                fkey: fkey,
+                openid_identifier: 'https://openid.stackexchange.com')
+
+    home = @agent.get "https://chat.#{site}.com"
+    if home.search(".topbar-links span.topbar-menu-links a").first.text.casecmp('log in').zero?
+      @logger.warn "Login to #{site} failed :("
+      false
+    else
+      @logger.info "Login to #{site} successful!"
+      true
+    end
+  end
+end

data/lib/chatx/events.rb

@@ -0,0 +1,195 @@
+require_relative 'models/message'
+require_relative 'models/room'
+require_relative 'models/user'
+
+EVENT = %w[
+  Message Posted
+  Message Edited
+  User Entered
+  User Left
+  Room Name Changed
+  Message Starred
+  Debug Message
+  User Mentioned
+  Message Flagged
+  Message Deleted
+  File Added
+  Moderator Flag
+  User Settings Changed
+  Global Notification
+  Access Level Changed
+  User Notification
+  Invitation
+  Message Reply
+  Message Moved Out
+  Message Moved In
+  Time Break
+  Feed Ticker
+  User Suspended
+  User Merged
+].freeze
+
+EVENT_SHORTHAND = %w[
+  message
+  edit
+  entrance
+  exit
+  rename
+  star
+  debug
+  mention
+  flag
+  delete
+  file
+  mod-flag
+  settings
+  gnotif
+  level
+  lnotif
+  invite
+  reply
+  move-out
+  move-in
+  time
+  feed
+  suspended
+  merge
+].freeze
+
+module ChatX
+  class Event
+    EVENT_CLASSES = {
+      1 => {
+        ChatX::Message => {
+          time_stamp: 'time_stamp',
+          content: 'content',
+          room_id: 'room_id',
+          user_id: 'user_id',
+          message_id: 'message_id'
+        }
+      },
+      2 => {
+        ChatX::Message => {
+          time_stamp: 'time_stamp',
+          content: 'content',
+          room_id: 'room_id',
+          user_id: 'user_id',
+          message_id: 'message_id'
+        }
+      },
+      3 => {
+        ChatX::User => {
+          user_id: 'target_user_id'
+        },
+        ChatX::Room => {
+          room_id: 'room_id'
+        }
+      },
+      4 => {
+        ChatX::User => {
+          user_id: 'target_user_id'
+        },
+        ChatX::Room => {
+          room_id: 'room_id'
+        }
+      },
+      5 => {
+        ChatX::Room => {
+          room_id: 'room_id'
+        }
+      },
+      # Note: A star/unstar/pin/unpin event DOES NOT have a user_id, which throws an error in ChatX::Message intialization.
+      # 6 => {
+      #   ChatX::Message => {
+      #     time_stamp: 'time_stamp',
+      #     content: 'content',
+      #     room_id: 'room_id',
+      #     user_id: 'user_id',
+      #     message_id: 'message_id'
+      #   }
+      # },
+      8 => {
+        ChatX::Message => {
+          time_stamp: 'time_stamp',
+          content: 'content',
+          room_id: 'room_id',
+          user_id: 'user_id',
+          message_id: 'message_id'
+        },
+        [ChatX::User, 'source_user'] => {
+          user_id: 'user_id'
+        },
+        [ChatX::User, 'target_user'] => {
+          user_id: 'target_user_id'
+        }
+      },
+      18 => {
+        ChatX::Message => {
+          time_stamp: 'time_stamp',
+          content: 'content',
+          room_id: 'room_id',
+          user_id: 'user_id',
+          message_id: 'message_id'
+        }
+      }
+    }.freeze
+
+    attr_reader :type, :type_long, :type_short, :hash
+
+    def initialize(event_hash, server, bot)
+      @type = event_hash['event_type'].to_i
+      @type_short = EVENT_SHORTHAND[@type - 1]
+      @type_long = EVENT[@type - 1]
+      @bot = bot
+
+      @etypes = []
+
+      @hash = event_hash # .delete("event_type")
+
+      # rubocop:disable Style/GuardClause
+      if EVENT_CLASSES.include? @type
+        classes = EVENT_CLASSES[@type]
+        classes.each do |c, i|
+          if c.class == Array
+            clazz = c[0]
+            method_name = c[1]
+          else
+            clazz = c
+            method_name = clazz.to_s.split('::').last.downcase
+          end
+          init_properties = i.map { |k, v| [k, event_hash[v]] }.to_h
+          # This bit is fun. It creates a ChatX::<event type> and uses the method_missing
+          # to make its methods all aliased to this ChatX::Event, and also defines an
+          # <event type> method on this ChatX::Event which returns the ChatX::<event type>
+          # object.
+          event_type_obj = clazz.new(server, **init_properties)
+          @etypes.push event_type_obj
+          instance_variable_set "@#{method_name}", event_type_obj
+          self.class.send(:define_method, method_name) do
+            instance_variable_get "@#{method_name}"
+          end
+        end
+      end
+      # rubocop:enable Style/GuardClause
+
+      def method_missing(m, *args, **opts, &block)
+        etypes = @etypes.select { |e| e.respond_to? m }
+        super if etypes.empty?
+        etype = etypes.first
+        if etype.respond_to? m
+          meth = etype.method(m)
+          # Because it treats **opts as 1 argument
+          if opts.empty?
+            meth.call(*args, &block)
+          else
+            meth.call(*args, **opts, &block)
+          end
+        end
+      end
+
+      def respond_to_missing?(m, *)
+        !@etypes.select { |e| e.respond_to? m }.empty? || super
+      end
+    end
+  end
+end