del 0.1.16 → 0.1.17

data/lib/del/configuration.rb

@@ -1,51 +1,80 @@
+# frozen_string_literal: true
+
 module Del
+  # This is used to contain all configuration.
   class Configuration
-    SOCKET_FILE="/tmp/del.sock"
-    attr_accessor :default_rooms
-    attr_accessor :host
-    attr_accessor :jid
-    attr_accessor :jid
-    attr_accessor :logger
-    attr_accessor :muc_domain
-    attr_accessor :name
-    attr_accessor :password
+    SOCKET_FILE = '/tmp/del.sock'
     attr_accessor :router
     attr_accessor :users
-    attr_accessor :socket_file
+    attr_writer :default_rooms
+    attr_writer :host
+    attr_writer :jid
+    attr_writer :logger
+    attr_writer :muc_domain
+    attr_writer :name
+    attr_writer :password
+    attr_writer :socket_file
 
     def initialize(settings = {})
-      @default_rooms = settings.fetch(:rooms, [])
-      @host = settings.fetch(:host, 'chat.hipchat.com')
-      @jid = settings.fetch(:jid)
-      @logger = Logger.new(STDOUT)
-      @logger.level = settings.fetch(:log_level, Logger::INFO).to_i
-      @muc_domain = settings.fetch(:muc_domain, "conf.hipchat.com")
-      @name = settings.fetch(:full_name)
-      @password = settings.fetch(:password)
+      @settings = settings
       @router = DefaultRouter.new
-      @socket_file = settings.fetch(:socket_file, SOCKET_FILE)
-      @users = Repository.new
+      @users = Repository.new(mapper: User)
+    end
+
+    def jid
+      @jid ||= settings.fetch(:jid)
+    end
+
+    def host
+      @host ||= settings.fetch(:host, 'chat.hipchat.com')
+    end
+
+    def muc_domain
+      @muc_domain ||= settings.fetch(:muc_domain, 'conf.hipchat.com')
+    end
+
+    def name
+      @name ||= settings.fetch(:full_name)
+    end
+
+    def password
+      @password ||= settings.fetch(:password)
+    end
+
+    def logger
+      @logger ||=
+        begin
+          x = Logger.new(STDOUT)
+          x.level = settings.fetch(:log_level, Logger::INFO).to_i
+          x
+        end
+    end
+
+    def socket_file
+      @socket_file ||= settings.fetch(:socket_file, SOCKET_FILE)
+    end
+
+    def default_rooms
+      @default_rooms ||= settings.fetch(:rooms, [])
     end
 
     def load(file)
       return if file.nil?
       return Kernel.load(file) if File.exist?(file)
-
-      eval(remote_fetch(file), binding)
+      download(file)
     end
 
     private
 
-    def remote_fetch(url)
-      require 'uri'
-      require 'net/http'
+    attr_reader :settings
+
+    def download(url)
+      Net::Hippie.logger = logger
+      content = Net::Hippie::Api.new(url).get
 
-      uri = URI.parse(url)
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = uri.is_a?(URI::HTTPS)
-      response = http.request(Net::HTTP::Get.new(uri.request_uri))
-      Del.logger.info("Loading...\n#{response.body}")
-      response.body
+      path = Tempfile.new('del').path
+      IO.write(path, content)
+      load(path)
     end
   end
 end

data/lib/del/default_router.rb

@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 module Del
+  # This class is the default router used
+  # to route chat messages to chat routes.
   class DefaultRouter
     def initialize(routes = [])
       @routes = routes
@@ -10,8 +14,11 @@ module Del
 
     def route(message)
       @routes.each do |route|
-        if matches = route[:pattern].match(message.text)
+        next unless (matches = route[:pattern].match(message.text))
+        begin
           route[:command].call(message, matches)
+        rescue StandardError => error
+          Del.logger.error(error)
         end
       end
     end

data/lib/del/examples/routes.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 Del.configure do |x|
-  puts "Registering custom routes."
+  puts 'Registering custom routes.'
 
   x.router.register(/.*/) do |message|
-    Del.logger.info("Backwards!")
+    Del.logger.info('Backwards!')
     message.reply(message.text.reverse)
   end
 
   x.router.register(/^cowsay (.*)/) do |message, match_data|
-    Del.logger.info("COWSAY!")
-    message.reply("/code #{`cowsay #{match_data[1]}`}")
+    Del.logger.info('COWSAY!')
+    message.execute_shell(['cowsay', match_data[1]])
   end
 
   x.router.register(/^[Hh]ello/) do |message|
-    message.reply("Hi!")
+    message.reply('Hi!')
   end
 end

data/lib/del/message.rb

@@ -1,6 +1,9 @@
+# frozen_string_literal: true
+
 module Del
+  # An XMPP Message
   class Message
-    PREFIX = "/code"
+    PREFIX = '/code'
     attr_reader :text, :robot, :source
 
     def initialize(text, robot:, source:)
@@ -14,21 +17,14 @@ module Del
     end
 
     def execute_shell(command)
-      command = Array(command).flatten.join(' ')
-      reply("Okay, I will run #{command}.")
-      success = false
-      Open3.popen3(command) do |stdin, stdout, stderr, wait_thr|
-        stdout.each_line do |line|
-          yield line if block_given?
-          reply("#{PREFIX} #{line}")
-        end
-        stderr.each_line do |line|
-          yield line if block_given?
+      reply("Okay, I'm on it!")
+      ShellCommand.new(command).run do |line|
+        if block_given?
+          yield line
+        else
           reply("#{PREFIX} #{line}")
         end
-        success = wait_thr.value.success?
       end
-      success
     end
 
     def to_s

data/lib/del/repository.rb

@@ -1,26 +1,33 @@
+# frozen_string_literal: true
+
 module Del
+  # This class is a facade for backend data storage.
   class Repository
-    def initialize(storage = {})
+    def initialize(storage: {}, mapper:)
       @storage = storage
+      @mapper = mapper
       @lock = Mutex.new
     end
 
     def [](id)
-      find_by(id)
+      find(id)
     end
 
-    def find_by(id)
+    def find(id)
       @lock.synchronize do
-        Del::User.new(id, @storage[id.to_s])
+        @mapper.map_from(@storage[id.to_s])
       end
     end
 
-    def find_all
-      @lock.synchronize { @storage.keys }
+    def all
+      @lock.synchronize do
+        @storage.map do |(_, value)|
+          @mapper.map_from(value)
+        end
+      end
     end
 
     def upsert(id, attributes = {})
-      Del.logger.debug([id, attributes].inspect)
       @lock.synchronize do
         @storage[id.to_s] = attributes
       end

data/lib/del/robot.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 module Del
+  # A funky robo-sapien.
   class Robot
     attr_reader :jid, :name
 
@@ -9,16 +12,21 @@ module Del
     end
 
     def get_funky!(start_server: true)
-      Del.logger.info("🔥🔥🔥")
+      Del.logger.info('🔥🔥🔥')
       xmpp_connection.connect(self)
-      socket_server.run(self) if start_server
+      if start_server
+        deltron = Del::Tron.new(self, configuration)
+        socket_server.run(deltron)
+      end
     rescue Interrupt
       xmpp_connection.disconnect
     end
 
     def receive(message, source:)
       return if source.from?(self)
-      configuration.router.route(Message.new(message, robot: self, source: source))
+      configuration.router.route(
+        Message.new(message, robot: self, source: source)
+      )
     end
 
     def send_message(jid, message)
@@ -29,13 +37,14 @@ module Del
       end
     end
 
-    def execute(request)
-      case request['command']
-      when 'send_message'
-        send_message(request['jid'], request['message'])
-        "Sent!"
-      else
-        "Unknown"
+    {
+      away!: :away,
+      busy!: :dnd,
+      offline!: :xa,
+      online!: :chat
+    }.each do |name, value|
+      define_method name do |message = nil|
+        xmpp_connection.update_status(value, message: message)
       end
     end
 
@@ -44,11 +53,12 @@ module Del
     attr_reader :configuration
 
     def xmpp_connection
-      @xmpp_connection ||= Connection.new(configuration: configuration)
+      @xmpp_connection ||= XMPPConnection.new(configuration: configuration)
     end
 
     def socket_server
-      @socket_server ||= SocketServer.new(socket_file: configuration.socket_file)
+      @socket_server ||=
+        SocketServer.new(socket_file: configuration.socket_file)
     end
 
     def user?(jid)

data/lib/del/send_message.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Del
+  class SendMessage
+    def initialize(shell, socket_file:)
+      @shell = shell
+      @socket = SocketMessage.new(@shell, socket_file: socket_file)
+    end
+
+    def run(jid, message)
+      @socket.deliver(
+        command: :send_message,
+        jid: jid,
+        message: message
+      )
+      @shell.say(@socket.listen, :green)
+    ensure
+      @socket.close
+    end
+  end
+end

data/lib/del/shell_command.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Del
+  # Executes shell commands and pipes the
+  # results back to the caller.
+  class ShellCommand
+    def initialize(command)
+      @command = Array(command).flatten.join(' ')
+    end
+
+    def run
+      Open3.popen3(@command) do |_stdin, stdout, stderr, wait_thr|
+        stdout.each_line { |line| yield line }
+        stderr.each_line { |line| yield line }
+        wait_thr.value.success?
+      end
+    end
+  end
+end

data/lib/del/socket_connection.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 module Del
   class SocketConnection
     def initialize(path:)
-      File.unlink(path) if File.exists?(path)
+      File.unlink(path) if File.exist?(path)
       @server = UNIXServer.new(path)
     end
 
     def on_receive
       socket = @server.accept
       yield socket
-    rescue => error
+    rescue StandardError => error
       Del.logger.error(error)
     ensure
       socket&.close

data/lib/del/socket_message.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Del
+  class SocketMessage
+    def initialize(shell, socket_file:)
+      @shell = shell
+      @socket_file = socket_file
+    end
+
+    def deliver(payload)
+      socket.puts(message_for(payload))
+    rescue EOFError => error
+      @shell.say error.message, :red
+    rescue Errno::ECONNREFUSED => error
+      @shell.say error.message, :red
+      @shell.say 'You must start the del server first.', :yellow
+    end
+
+    def listen
+      socket.readline
+    end
+
+    def close
+      socket&.close
+    end
+
+    private
+
+    def message_for(payload)
+      JSON.generate(payload)
+    end
+
+    def socket
+      @socket ||= UNIXSocket.new(@socket_file)
+    end
+  end
+end

data/lib/del/socket_server.rb

@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 module Del
+  # A Socket server for client/server communication
+  # overs a UNIX socket.
   class SocketServer
     def initialize(socket_file:)
       @connection = SocketConnection.new(path: socket_file)

data/lib/del/source.rb

@@ -1,4 +1,7 @@
+# frozen_string_literal: true
+
 module Del
+  # This represents the source of a chat message.
   class Source
     attr_reader :user, :room
 

data/lib/del/tron.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Del
+  class Tron
+    attr_reader :robot, :configuration
+
+    def initialize(robot, configuration)
+      @robot = robot
+      @configuration = configuration
+    end
+
+    def execute(request)
+      command_for(request)&.call(request) || 'Unknown'
+    rescue StandardError => error
+      error.message
+    end
+
+    private
+
+    def commands
+      {
+        change_status: ->(request) { change_status(request) },
+        send_message: ->(request) { send_message(request) },
+        users: ->(request) { users(request) },
+        whoami: ->(request) { whoami(request) },
+        whois: ->(request) { JSON.generate(whois(request['q'])) }
+      }
+    end
+
+    def command_for(request)
+      commands[request['command'].to_sym]
+    end
+
+    def whois(jid)
+      configuration.users[jid]&.attributes || {}
+    end
+
+    def send_message(request)
+      robot.send_message(request['jid'], request['message'])
+      'Sent!'
+    end
+
+    def users(_request)
+      JSON.generate(configuration.users.all.map(&:attributes))
+    end
+
+    def whoami(_request)
+      JSON.generate(whois(robot.jid))
+    end
+
+    def change_status(request)
+      robot.public_send("#{request['status'].downcase}!", request['message'])
+      'Done!'
+    rescue NoMethodError
+      'Error: Invalid status'
+    end
+  end
+end