chatx 0.0.0.pre.pre3 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9cc5eac4b2cb23bd725fc867b2f9fca4ac7376c1bc6c9e9ac282d0914d0e0192
-  data.tar.gz: bee11dafb91d70ab00a3ac536da183289941cd8e69a823e7b53a060fd25e91a6
+  metadata.gz: 21350e4e1273f200f9fb7392ef983d0d937669407963ecb1d684a5c8ea9bb5e2
+  data.tar.gz: f1fa848b2d9512a8fcc64aa1ad638414a44014b773a1eda2444eccacc5394d17
 SHA512:
-  metadata.gz: a9b73297e51bf6bced36b85be3863d7939f53389e5ec49d2a76a1c684d4f80800d94a11f380ac45a51141af8871626c46b4f3be637d180a150636a7cf782e77d
-  data.tar.gz: db034d9d9525a8d2da916924f793cf1f2ad1ff1aff92ea66fa6c685b212e27a9d1c38bdbbeaef11c1380b35c11fadee374addd05fd9102d3746e1a3c05f98324
+  metadata.gz: a881419f0f69339cde92ec726860aaf7d9ffc79066d64cbdf1abf1035bab1fa91c8f6ff8ba619c756dd1faf4cf6d980a20c05d1511a64989b966500ff2db1c00
+  data.tar.gz: ef288b1b5932541dde877a838b92d4556c74f77f939b3831976c71e90a0a263788d00073c551fa51e47bc9eff8d034169d597ceacc3948e271afa38af26e1c56

data/README.md

@@ -1,34 +1,32 @@
 # ChatX
 
-ChatX is a shorter and better and more ruby version of the ChatExchange python library for interacting with
+ChatX is a more ruby version of the ChatExchange python library for interacting with
 Stack Exchange Chat, Stack Overflow Chat, and Meta Stack Exchange Chat.
 
-The first thing to do is to go and make a chat account on the servers you want to use. Then, you can start with this
-gem.
+The first thing to do is to go and make a chat account on the servers you want to use. Then, you can start with this gem.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'chatx'
+gem 'chatx', git: 'https://gitlab.com/izwick-schachter/ChatX.git', branch: 'master'
 ```
 
 And then execute:
 
     $ bundle
 
-Or install it yourself as:
+Or install it yourself from rubygems (NOT RECOMMENDED) as:
 
     $ gem install chatx
-
 ## Usage
 
 The first thing you need is to create a new `ChatBot` and tell it what username you used, the password you used. If you
 want it to operate on a site besides chat.stackexchange.com, you'll have to specify it:
 
 ```ruby
-my_chatbot = ChatBot.new("smartbot@example.com", "correct horse battery staple")
+my_chatbot = ChatBot.new("smartbot@example.com", "correct horse battery staple", default_server: 'stackexchange')
 ```
 
 If you want to improve your security a bit further, you could also get the username and password from environment
@@ -61,7 +59,7 @@ Or, if you wanted to make that a reply to the "!!/alive" message, you could do:
 
 ```ruby
 my_chatbot.add_hook 1, "message" do |msg|
-  msg.reply "Yup, I'm here"
+  reply_to msg, "Yup, I'm here"
 end
 ```
 
@@ -109,6 +107,10 @@ my_chatbot.gen_hooks do
         e.reply "Good #{tod} to you as well!"
       end
     end
+    
+    command '!!/add' do |*args|
+      say args.map(&:to_i).sum
+  	end
   end
 end
 ```
@@ -138,4 +140,4 @@ The gem is available as open source under the terms of the [MIT License](http://
 ## Code of Conduct
 
 Everyone interacting in the ChatX project’s codebases, issue trackers, chat rooms and mailing lists is expected to
-follow the [code of conduct](https://github.com/[USERNAME]/chatx/blob/master/CODE_OF_CONDUCT.md).
+follow the [code of conduct](https://github.com/[USERNAME]/chatx/blob/master/CODE_OF_CONDUCT.md).

data/lib/chatx.rb

@@ -4,6 +4,7 @@ require "websocket/driver"
 require "json"
 require "permessage_deflate"
 require "open-uri"
+require "htmlentities"
 require_relative "chatx/events"
 require_relative "chatx/auth"
 require_relative "chatx/websocket"
@@ -32,7 +33,7 @@ class ChatBot
   #     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_reader :rooms, :websockets, :logger, :agent
   attr_accessor :default_server, :hooks
 
   # Creates a bot.
@@ -56,12 +57,13 @@ class ChatBot
 
     @ws_json_logger = Logger.new 'websockets_json.log'
 
+    # Both of these can be overriden in #login with cookie:
     @email = email
     @password = password
     @agent = Mechanize.new
     @rooms = {} # room_id => {events}
     @default_server = opts[:default_server]
-    @hooks = {}
+    @hooks = {'*' => []}
     @websockets = {}
     at_exit { rejoin }
   end
@@ -71,8 +73,9 @@ class ChatBot
   # @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)
+    servers = [servers] unless servers.is_a?(Array) || servers.is_a?(Hash)
+    return if authenticate(servers)
+    throw "Login failed; Exiting."
   end
 
   # Attempts to join a room, and for every room joined opens a websocket.
@@ -88,7 +91,7 @@ class ChatBot
   #   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}"
+    @logger.info "Joining #{room_id} on server #{server}"
 
     fkey = get_fkey(server, "rooms/#{room_id}")
 
@@ -122,18 +125,24 @@ class ChatBot
 
     @logger.info "Rooms: #{@rooms.keys}"
 
-    unless @websockets[server].nil?
-      @websockets[server].driver.close
+    unless @websockets[server].nil? || @websockets[server].dead
       @logger.info "Websocket #{@websockets[server]} already open; clearing."
+      @websockets[server].close
       @websockets[server] = nil
     end
+    @logger.info "SOOOOOOOOOOOOOOOOOOOOOOOOOOOO"
     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("; ")
+    @logger.info "Launching new WSCLient"
     @websockets[server] = WSClient.new("#{ws_uri}?l=#{last_event_time}", cookies, self, server)
     @logger.info "New websocket open (#{@websockets[server]}"
   end
 
+  def join_rooms(*rooms, server: @default_server)
+    rooms.flatten.each { |rid| join_room(rid) }
+  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.
@@ -155,17 +164,22 @@ class ChatBot
   # @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
+    @logger.warn "Message too long, truncating each line to 500 chars: #{content}" if content.to_s.split("\n").any? { |line| line.length > 500 }
+    resp ||= nil
+    loop do
+      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
+      break unless JSON.parse(resp.content)["id"].nil?
+      content = " #{content}"
     end
     return JSON.parse(resp.content)["id"].to_i
   end

data/lib/chatx/auth.rb

@@ -1,19 +1,29 @@
 class ChatBot
   def authenticate(sites = ["stackexchange"])
-    sites = [sites] unless sites.is_a?(Array)
+    if sites.is_a? Hash
+      sites.each do |site, cookie_str|
+        cookie = Mechanize::Cookie.new("acct", cookie_str)
+        cookie.domain = ".#{site}.com"
+        cookie.path = "/"
+        @agent.cookie_jar.add!(cookie)
+      end
+      true
+    else
+      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")
+      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)
+      @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
+      auth_results = sites.map { |s| site_auth(s) }
+      failed = auth_results.any?(&:!)
+      !failed
+    end
   end
 
   def site_auth(site)

data/lib/chatx/events.rb

@@ -65,7 +65,8 @@ module ChatX
           content: 'content',
           room_id: 'room_id',
           user_id: 'user_id',
-          message_id: 'message_id'
+          message_id: 'message_id',
+          parent_id: 'parent_id'
         }
       },
       2 => {

data/lib/chatx/hooks.rb

@@ -8,22 +8,22 @@ class ChatBot
   #
   # @note This method is strictly internal.
   # @param data [Hash] It's the JSON passed by the websocket
-  def handle(data, server: @default_server)
+  def handle(data, 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 "#{event.type_long}: #{event.hash}"
         @ws_json_logger.info "Currently in rooms #{@rooms.keys} / #{current_rooms}"
-        break if @rooms[room_id].nil?
+        next 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|
+        @hooks[server] ||= {}
+        (Array(@hooks[server][event_type.to_i])+Array(@hooks[server]['*'])+Array(@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 == '*'
+            hook.call(event, room_id) if rm_id == room_id || rm_id == '*'
           end
         end
       end
@@ -37,9 +37,16 @@ class ChatBot
   #   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]
+  def add_hook(room_id, event, server: @default_server, &action)
+    @hooks[server] ||= {}
+    @hook ||= Hook.new(self)
+    if event == '*'
+      @hooks[server]['*'] ||= []
+      @hooks[server]['*'].push [room_id, action]
+    else
+      @hooks[server][EVENT_SHORTHAND.index(event)] ||= []
+      @hooks[server][EVENT_SHORTHAND.index(event)].push [room_id, action]
+    end
   end
 
   # A simpler syntax for creating {add_hook} to the "Message Posted" event.
@@ -60,22 +67,25 @@ class Hook
   attr_reader :bot
   attr_accessor :current_room
 
-  def initialize(bot)
+  def initialize(bot, server: nil)
     @bot = bot
+    @default_server = server || @bot.default_server
   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)
+  def room(room_id, autojoin: true, server: @default_server, &block)
+    room = Room.new(room_id, self, server: server)
+    @bot.join_room(room_id.to_i, server: server) unless !autojoin || @bot.rooms.keys.include?(room_id)
     room.instance_eval(&block)
   end
 
-  def on(event, &block)
-    @bot.hooks[EVENT_SHORTHAND.index(event)] ||= []
-    @bot.hooks[EVENT_SHORTHAND.index(event)].push ['*', block]
+  def on(event, server: @default_server, &block)
+    @bot.hooks[server] ||= {}
+    @bot.hooks[server][EVENT_SHORTHAND.index(event)] ||= []
+    @bot.hooks[server][EVENT_SHORTHAND.index(event)].push ['*', block]
   end
 
   def command(prefix, &block)
@@ -89,23 +99,25 @@ class Hook
   end
 
   class Room < Hook
-    def initialize(room_id, hook)
+    def initialize(room_id, hook, server: nil)
       @hook = hook
       @bot = hook.bot
       @room_id = room_id
+      @default_server = server || @bot.default_server
     end
 
     def say(msg)
-      @bot.say(msg, @room_id)
+      @bot.say(msg, @room_id, server: @default_server)
     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]
+    def on(event, server: @default_server, &block)
+      @bot.hooks[server] ||= {}
+      @bot.hooks[server][EVENT_SHORTHAND.index(event)] ||= []
+      @bot.hooks[server][EVENT_SHORTHAND.index(event)].push [@room_id, block]
     end
   end
 end

data/lib/chatx/models/message.rb

@@ -27,6 +27,8 @@ module ChatX
       @parent_id = opts[:parent_id]
     end
 
+    alias_method :body, :content
+
     def reply(bot, content)
       bot.say ":#{id} #{content}", @room.id, server: @server
     end

data/lib/chatx/version.rb

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

data/lib/chatx/websocket.rb

@@ -1,76 +1,135 @@
 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!" }
+  attr_reader :url, :thread, :driver, :in_rooms, :dead
+  attr_accessor :handler
+
+  def initialize(url, cookies, bot, server, message_log: 'ws_messages.log', error_log: 'ws_errors.log', info_log: 'ws_info.log', dev_log: 'ws_dev.log')
+    # Setup loggers
+    @message_logger = Logger.new(message_log) if message_log
+    @error_logger = Logger.new(error_log) if error_log
+    @info_logger = Logger.new(info_log) if info_log
+    @dev_logger = Logger.new(dev_log) if dev_log
+
+    @bot = bot
+    @in_rooms = {rooms: [], last_update: Time.now}
+    @server = server
+
+    # Get WS(S) URI
+    @uri = URI.parse(url)
+    @url = "ws#{@uri.scheme.split("")[4]}://#{@uri.host}#{@uri.path}?#{@uri.query}"
+
+    # Setup handler (the action that's executed on message)
+    @handler = handler
+
+    # Auto-restart unless you don't
+    @restart = true
+    @dev_logger.info "Set @restart to #{@restart}"
+
+    setup(cookies: cookies, origin: "https://chat.#{@server}.com")
+  end
+
+  def send(message)
+    @message_logger.info(message)
+    @driver.text(message)
+  end
+
+  def write(data)
+    @socket.write(data)
+  end
+
+  def close
+    @info_logger.warn "Was told to close. Was sad."
+    @dead = true
+    @driver.close
+    @socket.is_a?(TCPSocket) ? @socket.shutdown : @socket.sysclose
+    @info_logger.info "Closed sucessfully"
+  rescue IOError, Errno::ENOTCONN => e
+    @logger.error "Recieved #{e.class} trying to close websocket. Ignoring..."
+  end
+
+  private
+
+  def setup(cookies: nil, origin: nil)
+    initialize_socket
+    initialize_driver(cookies: cookies, origin: origin)
+    launch_thread
+  end
+
+  def initialize_socket
+    if @uri.scheme[-1] == 's'
+      @socket = TCPSocket.new(@uri.host, 443)
+      @info_logger.info "Opened TCP socket for (port 443) #{@uri} (#{@socket})"
+      @socket = OpenSSL::SSL::SSLSocket.new(@socket)
+      @socket.connect
+      @info_logger.info "Upgrade TCP socket to SSL socket socket for #{@uri} (#{@socket})"
+      @info_logger.info "Current socket state: #{@socket.state}"
+    else
+      @socket = TCPSocket.new(@uri.host, 80)
+      @info_logger.info "Opened TCP socket for (port 80) #{@uri} (#{@socket})"
+    end
+  end
+
+  def initialize_driver(cookies: nil, origin: nil)
+    @driver = WebSocket::Driver.client(self)
+    @driver.add_extension PermessageDeflate
+    @driver.set_header "Cookies", cookies if cookies
+    origin = origin || "#{@uri.scheme}://#{@uri.host.split('.')[-2..-1].join('.')}"
+    @driver.set_header "Origin", origin
+
+    @info_logger.info "Creating new driver with origin: #{origin} and with#{'out' if !cookies} cookies"
+
+    @driver.on :connect, ->(_e) do
+      @info_logger.info "Sucessfully connected!"
+    end
+
+    @driver.on :open, ->(e) do
+      @info_logger.info "WebSocket is open!"
+    end
 
     @driver.on :message do |e|
-      @logger.info "Read:  #{e.data}"
-      @bot.handle(JSON.parse(e.data))
+      @message_logger.info(e.data)
+      @bot.handle(JSON.parse(e.data), server: @server)
       @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."
+      @info_logger.info "WebSocket driver is closing."
       if @restart
-        @bot.logger.info "Attempting to reopen websocket..."
-        @driver.start
+        restart
       end
     end
 
-    @driver.on :error, ->(e) { @bot.logger.error e }
+    @driver.on :error, ->(e) { @error_logger.error e }
 
     @driver.start
+  end
+
+  def restart
+    @info_logger.info "Attempting ro rejoin rooms #{@in_rooms[:rooms]}"
+    @bot.join_rooms(@in_rooms[:rooms])
+  end
+
+  def parse(data)
+    @driver.parse(data)
+  end
 
+  def launch_thread
+    # @info_logger.info "Waiting for old thread to complete..." if @thread
+    # @thread.join if @thread
+    # @info_logger.info "Starting new thread!"
+    @dead = false
     @thread = Thread.new do
       trap("SIGINT") do
         @restart = false
+        @dead = true
         close
         Thread.exit
       end
       begin
-        loop { @driver.parse(@tcp.recv(1)) }
+        parse(@socket.is_a?(TCPSocket) ? @socket.recv(1) : @socket.sysread(1)) until @dead
       rescue IOError, SystemCallError => e
-        @bot.logger.debug "Recieved #{e} closing TCP socket. You shouldn't be worried :)"
+        @info_logger.warn "Recieved #{e} closing TCP socket. You shouldn't be worried :)"
       end
+      @info_logger.warn "Left TCPSocket.recv loop. If you're reading this, panic."
     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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chatx
 version: !ruby/object:Gem::Version
-  version: 0.0.0.pre.pre3
+  version: 0.0.1
 platform: ruby
 authors:
 - izwick-schachter
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-12-25 00:00:00.000000000 Z
+date: 2018-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -239,9 +239,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.7.3