meshchat 0.8.0 → 0.10.0

data/lib/meshchat/display/base.rb

@@ -1,60 +0,0 @@
-module MeshChat
-  module Display
-    class Base
-
-      # instantiate the UI, startup the CLI
-      def start
-        fail 'overload this method'
-      end
-
-      # output a generic line of text
-      def add_line(_line)
-        fail 'overload this method'
-      end
-
-      # formatter for a whisper message
-      def whisper(_line)
-        fail 'overload this method'
-      end
-
-
-      # an emote
-      def emote(_line)
-        fail 'overload this method'
-      end
-
-
-      # server info or other ignorable information
-      def info(_line)
-        fail 'overload this method'
-      end
-
-      # warning message that the user may or may not care about
-      def warning(_line)
-        fail 'overload this method'
-      end
-
-      # really try to get the user's attention
-      def alert(_line)
-        fail 'overload this method'
-      end
-
-      # a happy message to affirm the user something succeded
-      def success(_line)
-        fail 'overload this method'
-      end
-
-      # general chat message
-      def chat(_line)
-        fail 'overload this method'
-      end
-
-
-
-      # log a message
-      def log(_msg)
-        fail 'overload this method'
-      end
-    end
-  end
-end

data/lib/meshchat/display/manager.rb

@@ -1,55 +0,0 @@
-require 'meshchat/display/base'
-
-module MeshChat
-  module Display
-    class Manager
-
-      attr_accessor :_ui
-
-      delegate :start, to: :_ui
-      delegate :add_line, to: :_ui
-      delegate :info, to: :_ui
-      delegate :emote, to: :_ui
-      delegate :warning, to: :_ui
-      delegate :alert, to: :_ui
-      delegate :success, to: :_ui
-      delegate :chat, to: :_ui
-      delegate :whisper, to: :_ui
-
-      attr_accessor :_logger
-      delegate :fatal, to: :_logger
-      delegate :debug, to: :_logger
-      delegate :error, to: :_logger
-
-      def initialize(ui_klass)
-        self._logger = Logger.new('debug.log')
-        self._ui = ui_klass.new
-      end
-
-      def present_message(message)
-        result = message.handle
-        return unless result
-
-        case message.class.name
-        when Message::Chat.name
-          chat result
-          Notify.show(summary: message.sender_name, body: message.message)
-        when Message::Whisper.name
-          whisper result
-          Notify.show(summary: message.sender_name, body: message.message)
-        when Message::Emote.name
-          emote result
-          Notify.show(summary: message.sender_name, body: message.message)
-        when Message::PingReply.name, Message::Ping.name
-          info result
-        when Message::NodeList.name,
-             Message::NodeListDiff.name,
-             Message::NodeListHash.name
-          # display nothing
-        else
-          add_line result
-        end
-      end
-    end
-  end
-end

data/lib/meshchat/instance.rb

@@ -1,40 +0,0 @@
-module MeshChat
-  class Instance
-    attr_accessor :client_name, :client_version, :display
-
-    class << self
-      delegate :client_name, :client_version, :display,
-        to: :instance
-
-      def start(options)
-        # calling instance to get things going
-        @instance = new(options)
-        @instance.start_input_device(options[:input])
-        @instance.start_ui(options[:display], options[:on_display_start])
-      end
-
-      def instance
-        @instance
-      end
-    end
-
-    def initialize(options = {})
-      self.client_name = options[:client_name] || MeshChat::NAME
-      self.client_version = options[:client_version] || MeshChat::VERSION
-    end
-
-    # @param [Class] klass should be something that implements Display::Base
-    # @param [Proc] proc what to do when starting the UI
-    def start_ui(klass, on_display_start)
-      self.display = Display::Manager.new(klass)
-      display.start do
-        on_display_start.call if on_display_start
-      end
-    end
-
-    def start_input_device(klass)
-      # The CLI is a singleton that takes a method of input
-      MeshChat::CLI.create(klass)
-    end
-  end
-end

data/lib/meshchat/message.rb

@@ -1,41 +0,0 @@
-require 'meshchat/message/base'
-require 'meshchat/message/chat'
-require 'meshchat/message/emote'
-require 'meshchat/message/ping'
-require 'meshchat/message/ping_reply'
-require 'meshchat/message/disconnect'
-require 'meshchat/message/whisper'
-require 'meshchat/message/relay'
-require 'meshchat/message/node_list'
-require 'meshchat/message/node_list_diff'
-require 'meshchat/message/node_list_hash'
-
-module MeshChat
-  module Message
-    CHAT = 'chat'
-    EMOTE = 'emote'
-    PING = 'ping'
-    PING_REPLY = 'pingreply'
-    WHISPER = 'whisper'
-    RELAY = 'relay'
-    DISCONNECT = 'disconnect'
-
-    NODE_LIST = 'nodelist'
-    NODE_LIST_HASH = 'nodelisthash'
-    NODE_LIST_DIFF = 'nodelistdiff'
-
-    TYPES = {
-      CHAT => Chat,
-      EMOTE => Emote,
-      WHISPER => Whisper,
-      DISCONNECT => Disconnect,
-      PING => Ping,
-      PING_REPLY => PingReply,
-      NODE_LIST => NodeList,
-      NODE_LIST_DIFF => NodeListDiff,
-      NODE_LIST_HASH => NodeListHash
-    }
-
-
-  end
-end

data/lib/meshchat/message/base.rb

@@ -1,97 +0,0 @@
-module MeshChat
-  module Message
-    #
-    # NOTE:
-    #  #display: shows the message
-    #            should be used locally, before *sending* a message
-    #  #handle: processing logic for the message
-    #           should be used when receiving a message, and there
-    #           needs to be a response right away
-    #  #respond: where the actual logic for the response goes
-    class Base
-      attr_accessor :payload, :time_recieved,
-        :message, :sender_name, :sender_location, :sender_uid
-
-      # @param [String] message
-      # @param [String] name_of_sender
-      # @param [String] location the location of the sender
-      # @param [Hash] payload optionally overrides the default payload
-      def initialize(
-        message: '',
-        sender_name: '',
-        sender_location: '',
-        sender_uid: '',
-        time_recieved: nil,
-        payload: nil)
-
-        @payload = payload.presence
-
-        # TODO: find a more elegant way to represent this
-        self.message = message.presence || @payload.try(:[], 'message')
-        self.sender_name = sender_name.presence || @payload.try(:[], 'sender').try(:[], 'alias') || Settings['alias']
-        self.sender_location = sender_location.presence || @payload.try(:[], 'sender').try(:[], 'location') || Settings.location
-        self.sender_uid = sender_uid.presence || @payload.try(:[], 'sender').try(:[], 'uid') || Settings['uid']
-        self.time_recieved = time_recieved.presence || Time.now
-
-      end
-
-      def payload
-        @payload ||= {
-          'type' => type,
-          'message' => message,
-          'client' => client,
-          'client_version' => client_version,
-          'time_sent' => time_recieved || Time.now.to_s,
-          'sender' => {
-            'alias' => sender_name,
-            'location' => sender_location,
-            'uid' => sender_uid
-          }
-        }
-      end
-
-      def type
-        @type ||= TYPES.invert[self.class]
-      end
-
-      def client
-        MeshChat.name
-      end
-
-      def client_version
-        MeshChat.version
-      end
-
-      def sender
-        payload['sender']
-      end
-
-      # shows the message
-      # should be used locally, before *sending* a message
-      def display
-        message
-      end
-
-      # processing logic for the message
-      # should be used when receiving a message, and there
-      # needs to be a response right away.
-      # this may call display, if the response is always to be displayed
-      def handle
-        display
-      end
-
-      # Most message types aren't going to need to have an
-      # immediate response.
-      #
-      def respond
-        return
-      end
-
-      # this message should be called immediately
-      # before sending to the whomever
-      def render
-        payload.to_json
-      end
-    end
-  end
-end

data/lib/meshchat/message/chat.rb

@@ -1,19 +0,0 @@
-module MeshChat
-  module Message
-    class Chat < Base
-
-      def display
-        time_recieved = self.time_recieved.strftime('%e/%m/%y %H:%I:%M')
-        name = payload['sender']['alias']
-        message = payload['message']
-
-        format_display(time_recieved, name, message)
-      end
-
-
-      def format_display(time, name, message)
-        "#{time} #{name} > #{message}"
-      end
-    end
-  end
-end

data/lib/meshchat/message/disconnect.rb

@@ -1,13 +0,0 @@
-module MeshChat
-  module Message
-    class Disconnect < Base
-      def display
-        location = payload['sender']['location']
-        name = payload['sender']['alias']
-        node = Node.find_by_location(location)
-        node.update(online: false) if node
-        "#{name}@#{location} has disconnected"
-      end
-    end
-  end
-end

data/lib/meshchat/message/emote.rb

@@ -1,9 +0,0 @@
-module MeshChat
-  module Message
-    class Emote < Chat
-      def format_display(time, name, message)
-        "#{time} #{name} #{message}"
-      end
-    end
-  end
-end

data/lib/meshchat/message/node_list.rb

@@ -1,63 +0,0 @@
-module MeshChat
-  module Message
-    class NodeList < Base
-      def message
-        @message ||= Node.as_json
-      end
-
-      def handle
-        respond
-        return
-      end
-
-      # only need to respond if this server has node entries that the
-      # sender of this message doesn't have
-      def respond
-        received_list = message
-        we_only_have, they_only_have = Node.diff(received_list)
-
-        Display.debug('node_list#respond: me: ' + we_only_have.to_s)
-        Display.debug('node_list#respond: they: ' + they_only_have.to_s)
-
-        if they_only_have.present?
-          they_only_have.each do |n|
-            Node.from_json(n).save!
-          end
-        end
-
-
-        location = payload['sender']['location']
-
-        node = Node.find_by_location(location)
-        if we_only_have.present?
-          Display.debug 'we have nodes that they do not'
-
-          # give the sender our list
-          MeshChat::Net::Client.send(
-            node: node,
-            message: NodeListDiff.new(message: we_only_have)
-          )
-
-          # give people we know about
-          # (but the sender of the Node List may not know about)
-          # our node list diff
-          Node.online.each do |entry|
-            MeshChat::Net::Client.send(
-              node: entry,
-              message: NodeListDiff.new(message: they_only_have)
-            )
-          end
-        else
-          Display.debug 'node lists are in sync'
-
-          # lists are in sync, confirm with hash
-          MeshChat::Net::Client.send(
-            node: node,
-            message: NodeListHash.new
-          )
-        end
-
-      end
-    end
-  end
-end

data/lib/meshchat/message/node_list_diff.rb

@@ -1,15 +0,0 @@
-module MeshChat
-  module Message
-    class NodeListDiff < Base      
-      def handle
-        entries_we_do_not_have = message
-
-        entries_we_do_not_have.each do |entry_as_json|
-          # this will silently fail if there is a duplicate
-          # or if this is an invalid entry
-          Node.from_json(entry_as_json).save
-        end
-      end
-    end
-  end
-end

data/lib/meshchat/message/node_list_hash.rb

@@ -1,33 +0,0 @@
-module MeshChat
-  module Message
-    class NodeListHash < Base
-      def message
-        @message ||= Node.as_sha512
-      end
-
-      # node list hash is received
-      # @return [NilClass] no output for this message type
-      def handle
-        respond
-        return
-      end
-
-      def respond
-        if message != Node.as_sha512
-          Display.debug 'node list hashes do not match'
-          location = payload['sender']['location']
-
-          Display.debug 'sending a node list to ' + location
-          node = Node.find_by_location(location)
-
-          MeshChat::Net::Client.send(
-            node: node,
-            message: NodeList.new(message: Node.as_json)
-          )
-        else
-          Display.debug 'node list hash matches'
-        end
-      end
-    end
-  end
-end