meshchat 0.8.0 → 0.10.0

data/lib/meshchat/network/remote/relay_pool.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+module Meshchat
+  module Network
+    module Remote
+      class RelayPool
+        # This channel is determine by the server, see
+        # https://github.com/NullVoxPopuli/mesh-relay/blob/master/app/channels/mesh_relay_channel.rb
+        CHANNEL = 'MeshRelayChannel'
+
+        attr_accessor :_message_dispatcher
+        attr_accessor :_active_relay
+        attr_accessor :_known_relays, :_available_relays
+
+        def initialize(message_dispatcher)
+          @_message_dispatcher = message_dispatcher
+          @_known_relays = APP_CONFIG.user['relays'] || []
+          @_available_relays = APP_CONFIG.user['relays'] || []
+
+          find_initial_relay if @_known_relays.present?
+        end
+
+        # TODO: add logic for just selecting the first available relay.
+        #       we only need one connection.
+        # @return [Array] an array of action cable clients
+        def find_initial_relay(connected: nil)
+          url = _known_relays.first
+          @_active_relay = Relay.new(
+            url, _message_dispatcher,
+            connected: connected)
+        end
+
+        # @param [Hash] payload - the message payload
+        def send_payload(payload)
+          return if _active_relay.blank?
+
+          ensure_active_connection! do
+            _active_relay.perform('chat', payload)
+          end
+        end
+
+        def ensure_active_connection!(&block)
+          # TODO: make action_cable_client return a boolean
+          if !_active_relay.connected?
+            find_initial_relay(connected: block)
+          else
+            yield
+          end
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/ui.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module Meshchat
+  module Ui
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :CLI
+      autoload :Command
+      autoload :Display
+      autoload :Notifier
+    end
+  end
+end

data/lib/meshchat/ui/cli.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+module Meshchat
+  module Ui
+    # A user interface is responsible for for creating a client
+    # and sending messages to that client
+    class CLI
+      extend ActiveSupport::Autoload
+
+      eager_autoload do
+        autoload :InputFactory
+        autoload :Base
+        autoload :KeyboardLineInput
+      end
+
+      attr_reader :_message_dispatcher, :_message_factory, :_command_factory
+
+      def initialize(dispatcher, message_factory, _display)
+        @_message_dispatcher = dispatcher
+        @_message_factory = message_factory
+        @_command_factory = InputFactory.new(dispatcher, message_factory, self)
+      end
+
+      def create_input(msg)
+        handler = _command_factory.create(for_input: msg)
+        handler.handle
+      rescue => e
+        Debug.creating_input_failed(e)
+      end
+
+      # save config and exit
+      def shutdown
+        # close_server
+        Display.info 'saving config...'
+        APP_CONFIG.user.save
+        Display.info 'notifying of disconnection...'
+        send_disconnect
+        Display.alert "\n\nGoodbye.  \n\nThank you for using #{Meshchat.name}"
+        exit
+      end
+
+      def send_disconnect
+        klass   = Command::SendDisconnect
+        command = _command_factory.create(with_class: klass)
+        command.handle
+      end
+    end
+  end
+end

data/lib/meshchat/ui/cli/base.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+module Meshchat
+  module Ui
+    class CLI
+      # this class, and all subclasses are Keyboard Handlers
+      # that are used for EventMachine's open_keyboard
+      # @see https://github.com/eventmachine/eventmachine/wiki/Code-Snippets#keyboard-input-example
+      class Base < EventMachine::Connection
+        # The class used for interpeting the line input
+        attr_reader :_input_receiver
+        # An array of typed keystrokes
+        attr_reader :_input_buffer
+
+        def initialize(input_receiver)
+          @_input_receiver = input_receiver
+          @_input_buffer = []
+        end
+
+        # override this method to alter how input is
+        # interpreted by the receiver.
+        #
+        # hopefully, just by calling a different method
+        # on the receiver, as input processing shouldn't
+        # occurr in this class or any subclass unless it is
+        # raw keystroke input
+        #
+        # @note that this method receives raw keystrokes by default
+        #        and does not send data to the input receiver
+        def receive_data(data)
+          _input_buffer.push(data)
+        end
+
+        def receive_line(line)
+          # only used when including EM::Protocols::LineText2
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/ui/cli/input_factory.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+module Meshchat
+  module Ui
+    class CLI
+      class InputFactory
+        WHISPER = '@'
+        COMMAND = '/'
+
+        attr_accessor :_message_dispatcher, :_message_factory, :_cli
+
+        def initialize(message_dispatcher, message_factory, cli)
+          self._message_dispatcher = message_dispatcher
+          self._message_factory    = message_factory
+          self._cli                = cli
+        end
+
+        def is_command?(input)
+          input[0, 1] == COMMAND
+        end
+
+        def is_whisper?(input)
+          input[0, 1] == WHISPER
+        end
+
+        def create(for_input: nil, with_class: nil)
+          return create_with_class(for_input, with_class) if with_class
+
+          create_for_input(for_input)
+        end
+
+        def create_with_class(input, klass)
+          klass.new(input, _message_dispatcher, _message_factory, self)
+        end
+
+        def create_for_input(input)
+          klass =
+            if is_command?(input)
+              Command::Base
+            elsif is_whisper?(input)
+              Command::Whisper
+            else
+              Command::Chat
+            end
+
+          create_with_class(input, klass)
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/ui/cli/keyboard_line_input.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Meshchat
+  module Ui
+    class CLI
+      class KeyboardLineInput < CLI::Base
+        include EM::Protocols::LineText2
+
+        def receive_line(data)
+          _input_receiver.create_input(data)
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/ui/command.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+module Meshchat
+  module Ui
+    module Command
+      extend ActiveSupport::Autoload
+
+      eager_autoload do
+        autoload :Base
+        autoload :Chat
+        autoload :Identity
+        autoload :Irb
+        autoload :Config
+        autoload :Ping
+        autoload :PingAll
+        autoload :Server
+        autoload :Whisper
+        autoload :Exit
+        autoload :SendDisconnect
+        autoload :Help
+        autoload :Bind
+        autoload :Online
+        autoload :Offline
+        autoload :Share
+        autoload :Import
+        autoload :Emote
+      end
+
+      COMMAND_MAP = {
+        Base::CONFIG          => Config,
+        Base::PING            => Ping,
+        Base::PING_ALL        => PingAll,
+        Base::SERVERS         => Server,
+        Base::SERVER          => Server,
+        Base::EXIT            => Exit,
+        Base::QUIT            => Exit,
+        Base::IDENTITY        => Identity,
+        Base::IRB             => Irb,
+        Base::SHARE           => Share,
+        Base::IMPORT          => Import,
+        Base::EXPORT          => Share,
+        Base::ONLINE          => Online,
+        Base::OFFLINE         => Offline,
+        Base::HELP            => Help,
+        Base::BIND            => Bind,
+        Base::SEND_DISCONNECT => SendDisconnect,
+        Base::EMOTE           => Emote,
+        Base::CHAT            => Chat
+      }.freeze
+    end
+  end
+end

data/lib/meshchat/ui/command/base.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+module Meshchat
+  module Ui
+    module Command
+      class Base
+        # Commands
+        SET = 'set'
+        CONFIG = 'config'
+        DISPLAY = 'display'
+        EXIT = 'exit'
+        QUIT = 'quit'
+        CHAT = 'chat'
+        ADD = 'add'
+        REMOVE = 'remove'
+        RM = 'rm'
+        SERVERS = 'servers'
+        SERVER = 'server'
+        WHO = 'who'
+        PING = 'ping'
+        PING_ALL = 'pingall'
+        IDENTITY = 'identity'
+        IRB = 'c'
+        SHARE = 'share'
+        IMPORT = 'import'
+        EXPORT = 'export'
+        ONLINE = 'online'
+        OFFLINE = 'offline'
+        HELP = 'help'
+        BIND = 'bind'
+        SEND_DISCONNECT = 'senddisconnect'
+        EMOTE = 'me'
+
+        attr_reader :_input, :_message_dispatcher
+        attr_reader :_message_factory, :_input_factory
+
+        def initialize(input, message_dispatcher, message_factory, input_factory)
+          @_input              = input&.chomp
+          @_message_dispatcher = message_dispatcher
+          @_message_factory    = message_factory
+          @_input_factory      = input_factory
+        end
+
+        def handle
+          klass = COMMAND_MAP[command]
+          Display.debug("INPUT: #{klass&.name} from #{command} derived from #{_input}")
+          if klass
+            _input_factory.create(for_input: _input, with_class: klass).handle
+          else
+            Display.alert 'not implemented...'
+          end
+        end
+
+        protected
+
+        def command_string
+          @command_string ||= _input[1, _input.length]
+        end
+
+        def command_args
+          @command_args ||= command_string.split(' ')
+        end
+
+        def command
+          @command ||= command_args.first
+        end
+
+        def sub_command_args
+          @sub_command_args ||= command_args[2..3]
+        end
+
+        def sub_command
+          @sub_command ||= command_args[1]
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/ui/command/bind.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+require 'socket'
+require 'open-uri'
+
+module Meshchat
+  module Ui
+    module Command
+      class Bind < Command::Base
+        def self.description
+          'helper for choosing what ip address to use for yourself'
+        end
+
+        def handle
+          options = ip_addresses
+          option_numbers = []
+          Display.success 'Choose an ip:'
+          options.each_with_index do |ip, index|
+            Display.info "#{index}: #{ip}"
+            option_numbers << index
+          end
+
+          selected = gets
+
+          if option_numbers.include?(selected.to_i)
+            Display.success Settings.set('ip', with: options[selected.to_i])
+          else
+            Display.alert 'Invalid selection'
+            handle # repeat
+          end
+        end
+
+        def ip_addresses
+          local = Socket.getifaddrs.map { |i| i.addr.ip_address if i.addr.ipv4? }.compact
+          # get public
+          begin
+            remote_ip = open('http://whatismyip.akamai.com').read
+            local << remote_ip
+          rescue => e
+            Display.fatal e.message
+            Display.alert 'public ip lookup failed'
+          end
+          local
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/ui/command/chat.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module Meshchat
+  module Ui
+    module Command
+      class Chat < Command::Base
+        def handle
+          servers = Node.online
+          if !servers.empty?
+            type = self.class.name.demodulize.downcase
+            m = _message_factory.create(type, data: { message: _input })
+            show_myself(m)
+
+            # if sending to all, iterate thorugh list of
+            # servers, and send to each one
+            # TODO: do this async so that one server doesn't block
+            # the rest of the servers from receiving the messages
+            servers.each do |entry|
+              _message_dispatcher.send_message(node: entry, message: m)
+            end
+          else
+            Display.warning 'you have no servers'
+          end
+        end
+
+        def show_myself(message)
+          Display.chat message.display
+        end
+      end
+    end
+  end
+end

data/lib/meshchat/ui/command/config.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module Meshchat
+  module Ui
+    module Command
+      class Config < Command::Base
+        def self.description
+          'interface for setting and displaying various config options'
+        end
+
+        def handle
+          case sub_command
+          when SET
+            if is_valid_set_command?
+              key, value = config_set_args
+
+              Display.info APP_CONFIG.user.set(key, with: value)
+            else
+              Display.alert 'set requires a key and a value'
+            end
+          when DISPLAY
+            Display.info APP_CONFIG.user.display
+          else
+            Display.alert 'config command not implemented...'
+          end
+        end
+
+        def config_set_args
+          command_args[2..3]
+        end
+
+        def is_valid_set_command?
+          sub_command == SET && command_args.length == 4
+        end
+      end
+    end
+  end
+end