aromancer 0.0.4 → 0.0.6

data/lib/aromancer/server.rb

@@ -13,8 +13,7 @@
 module Aromancer
   class Server
     include Singleton
-    SERVER_HOST_FILE = ".aromancer_server_host"
-    SERVER_URL = File.exist?(SERVER_HOST_FILE) ? File.read(SERVER_HOST_FILE).gsub("\n", "") : "http://localhost:3000"
+
     HEADERS = { "Content-Type": "application/json" }
 
     class InternalError
@@ -23,26 +22,25 @@ module Aromancer
       def initialize(status: -1, body: {})
         @status = status
         @body = body
+        Aromancer::Storage.instance.clear_cache!
       end
 
       def self.build(e)
         InternalError.new(
           status: -1,
-          body: {error_message: e.message[0..78]}.to_json
+          body: {error_message: e.inspect.to_s}.to_json
         )
       end
     end
 
-    def self.api_key_param
-      {
-        api_key: Aromancer::Storage.get_player["api_key"]
-      }
+    def self.auth_header
+      {"Authorization": "Bearer #{Aromancer::Storage.get_player["api_key"]}"}
     end
 
     def self.sign_in(email_address, password)
       begin
         Faraday.new(
-          url: SERVER_URL,
+          url: Aromancer::Storage.get_server_url,
           headers: HEADERS,
           params: {
             email_address: email_address,
@@ -57,7 +55,7 @@ module Aromancer
     def self.sign_up(email_address, password, password_confirmation)
       begin
         Faraday.new(
-          url: SERVER_URL,
+          url: Aromancer::Storage.get_server_url,
           headers: HEADERS,
           params: {
             user: {
@@ -75,9 +73,8 @@ module Aromancer
     def self.sign_out
       begin
         Faraday.new(
-          url: SERVER_URL,
-          headers: HEADERS,
-          params: api_key_param
+          url: Aromancer::Storage.get_server_url,
+          headers: HEADERS.merge(auth_header),
         ).delete("/session")
       rescue StandardError => e
         InternalError.build(e)
@@ -87,9 +84,9 @@ module Aromancer
     def self.create_legend(params)
       begin
         Faraday.new(
-          url: SERVER_URL,
-          headers: HEADERS,
-          params: params.merge(api_key_param)
+          url: Aromancer::Storage.get_server_url,
+          headers: HEADERS.merge(auth_header),
+          params: params
         ).post("/legends")
       rescue StandardError => e
         InternalError.build(e)
@@ -99,21 +96,31 @@ module Aromancer
     def self.get_legends
       begin
         Faraday.new(
-          url: SERVER_URL,
-          headers: HEADERS,
-          params: api_key_param
+          url: Aromancer::Storage.get_server_url,
+          headers: HEADERS.merge(auth_header),
         ).get("/legends")
       rescue StandardError => e
         InternalError.build(e)
       end
     end
 
+    def self.find_legends
+      begin
+        Faraday.new(
+          url: Aromancer::Storage.get_server_url,
+          headers: HEADERS.merge(auth_header),
+        ).get("/legends/find")
+      rescue StandardError => e
+        InternalError.build(e)
+      end
+    end
+
     def self.update_player(params)
       begin
         Faraday.new(
-          url: SERVER_URL,
-          headers: HEADERS,
-          params: params.merge(api_key_param)
+          url: Aromancer::Storage.get_server_url,
+          headers: HEADERS.merge(auth_header),
+          params: params
         ).put("/players/#{Aromancer::Storage.get_player["id"]}")
       rescue StandardError => e
         InternalError.build(e)
@@ -121,13 +128,13 @@ module Aromancer
     end
 
     def self.get_arena
-      legend_id = Aromancer::Storage.get_player["active_legend_id"]
+      legend_id = (Aromancer::Storage.get_player || {})["active_legend_id"]
+      return InternalError.build(StandardError.new("no active legend")) if legend_id.nil?
 
       begin
         Faraday.new(
-          url: SERVER_URL,
-          headers: HEADERS,
-          params: api_key_param
+          url: Aromancer::Storage.get_server_url,
+          headers: HEADERS.merge(auth_header),
         ).get("/legends/#{legend_id}/arena")
       rescue StandardError => e
         InternalError.build(e)
@@ -135,13 +142,13 @@ module Aromancer
     end
 
     def self.get_stream
-      legend_id = Aromancer::Storage.get_player["active_legend_id"]
+      legend_id = (Aromancer::Storage.get_player || {})["active_legend_id"]
+      return InternalError.build(StandardError.new("no active legend")) if legend_id.nil?
 
       begin
         Faraday.new(
-          url: SERVER_URL,
-          headers: HEADERS,
-          params: api_key_param
+          url: Aromancer::Storage.get_server_url,
+          headers: HEADERS.merge(auth_header),
         ).get("/legends/#{legend_id}/stream")
       rescue StandardError => e
         InternalError.build(e)
@@ -149,12 +156,13 @@ module Aromancer
     end
 
     def self.get_word_possibilities(selected_word_id)
-      legend_id = Aromancer::Storage.get_player["active_legend_id"]
+      legend_id = (Aromancer::Storage.get_player || {})["active_legend_id"]
+      return InternalError.build(StandardError.new("no active legend")) if legend_id.nil?
+
       begin
         Faraday.new(
-          url: SERVER_URL,
-          headers: HEADERS,
-          params: api_key_param
+          url: Aromancer::Storage.get_server_url,
+          headers: HEADERS.merge(auth_header),
         ).get("/legends/#{legend_id}/words/#{selected_word_id}/possibilities")
       rescue StandardError => e
         InternalError.build(e)
@@ -162,12 +170,14 @@ module Aromancer
     end
 
     def self.create_turn(params)
-      legend_id = Aromancer::Storage.get_player["active_legend_id"]
+      legend_id = (Aromancer::Storage.get_player || {})["active_legend_id"]
+      return InternalError.build(StandardError.new("no active legend")) if legend_id.nil?
+
       begin
         Faraday.new(
-          url: SERVER_URL,
-          headers: HEADERS,
-          params: params.merge(api_key_param)
+          url: Aromancer::Storage.get_server_url,
+          headers: HEADERS.merge(auth_header),
+          params: params
         ).post("/legends/#{legend_id}/arena")
       rescue StandardError => e
         InternalError.build(e)
@@ -175,12 +185,14 @@ module Aromancer
     end
 
     def self.update_turn(params)
-      legend_id = Aromancer::Storage.get_player["active_legend_id"]
+      legend_id = (Aromancer::Storage.get_player || {})["active_legend_id"]
+      return InternalError.build(StandardError.new("no active legend")) if legend_id.nil?
+
       begin
         Faraday.new(
-          url: SERVER_URL,
-          headers: HEADERS,
-          params: params.merge(api_key_param)
+          url: Aromancer::Storage.get_server_url,
+          headers: HEADERS.merge(auth_header),
+          params: params
         ).put("/legends/#{legend_id}/arena")
       rescue StandardError => e
         InternalError.build(e)

data/lib/aromancer/storage.rb

@@ -12,10 +12,20 @@ module Aromancer
   class Storage
     include Singleton
 
+    DEFAULT_SERVER = "http://aromancer.com"
+
+    attr_accessor :storage_open, :cache
+
     def initialize
+      clear_cache!
       FileUtils.mkdir_p(Aromancer.home_directory)
     end
 
+    def clear_cache!
+      @storage_open = false
+      @cache = {}
+    end
+
     def self.storage_filepath
       filepath = File.join(Aromancer.home_directory, "storage.json")
 
@@ -53,6 +63,17 @@ module Aromancer
       instance.set_key(p_key, value)
     end
 
+    def self.toggle_preference(key)
+      set_preference(key, !get_preference(key))
+    end
+
+    def self.toggle_force_ssl
+      toggle_preference(:force_ssl)
+      v = get_preference(:force_ssl)
+      self.instance.set_key(:server_url_scheme, "http#{v ? :s : ""}")
+      self.instance.set_key(:websocket_scheme, "ws#{v ? :s : ""}")
+    end
+
     def self.set_signed_out_flag(flag)
       Aromancer::Storage.instance.set_key(:signed_out_flag, flag)
     end
@@ -101,20 +122,131 @@ module Aromancer
       Aromancer::Storage.instance.get_key(:last_error)
     end
 
+    URI_KEYS = [
+      :scheme,
+      :host,
+      :port
+    ]
+
+    def self.set_server_url(server_url)
+      uri = URI.parse(server_url)
+      if uri.kind_of?(URI::HTTP) or uri.kind_of?(URI::HTTPS)
+        URI_KEYS.each{|k|
+          uri.kind_of?(URI::HTTP) && get_preference(:force_ssl) ? toggle_force_ssl : nil
+          Aromancer::Storage.instance.set_key("server_url_#{k}", uri.select(k).first)
+        }
+      elsif get_server_url.nil?
+        set_server_url(DEFAULT_SERVER)
+      end
+    end
+
+    def self.get_server_url
+      set_server_url(DEFAULT_SERVER) if URI_KEYS.all?{|k| Aromancer::Storage.instance.get_key("server_url_#{k}").nil?}
+      URI.parse(URI_KEYS.map{|k|
+        c = Aromancer::Storage.instance.get_key("server_url_#{k}")
+        case k
+        when :scheme
+          "#{c}://"
+        when :host
+          c
+        when :port
+          ":#{c}"
+        end
+      }.join("")).to_s
+    end
+
+    def self.get_websocket_url
+      # default scheme is ws
+      w_scheme = Aromancer::Storage.instance.get_key(:websocket_scheme)
+      Aromancer::Storage.instance.set_key(:websocket_scheme, :ws) if w_scheme.nil?
+      w_scheme = Aromancer::Storage.instance.get_key(:websocket_scheme)
+
+      # default path is broadcast
+      w_path = Aromancer::Storage.instance.get_key(:websocket_path)
+      Aromancer::Storage.instance.set_key(:websocket_path, :broadcast) if w_path.nil?
+      w_path = Aromancer::Storage.instance.get_key(:websocket_path)
+
+      # asserts host and port not nil
+      # assumes same-as-server host and port for now
+      host = Aromancer::Storage.instance.get_key(:server_url_host)
+      port = Aromancer::Storage.instance.get_key(:server_url_port)
+
+      URI.parse("#{w_scheme}://#{host}:#{port}/#{w_path}").to_s
+    end
+
     def get_key(key)
-      storage_contents = JSON.parse(File.read(Aromancer::Storage.storage_filepath))
-      if storage_contents.keys.include?(key.to_s)
-        return storage_contents[key.to_s]
+      key = key.to_s
+
+      # ensure default for key exists
+      @cache[key] = {value: nil, persisted: false} unless @cache.keys.include?(key)
+
+      # return cache value if storage open or the cache value is persisted
+      return @cache[key][:value] if @storage_open || @cache[key][:persisted]
+
+      # open storage
+      @storage_open = true
+      storage_contents = {}
+      begin
+        # read storage
+        storage_contents = JSON.parse(File.read(Aromancer::Storage.storage_filepath))
+      rescue StandardError => e
+        @storage_open = false
+        FileUtils.rm(Aromancer::Storage.storage_filepath)
+        return
       end
+
+      # only update the cache value if present in storage
+      if storage_contents.keys.include?(key)
+        @cache[key] = {value: storage_contents[key], persisted: true}
+      else
+        @cache[key][:persisted] = false
+      end
+
+      @storage_open = false
+      @cache[key][:value]
     end
 
     def set_key(key, value)
-      storage_contents = JSON.parse(File.read(Aromancer::Storage.storage_filepath))
-      storage_contents[key.to_s] = value
+      key = key.to_s
+
+      # ensure default for key exists
+      @cache[key] = {value: nil, persisted: false} unless @cache.keys.include?(key)
+
+      # assign new cache value and set persisted to false
+      @cache[key][:value] = value
+      @cache[key][:persisted] = false
+
+      # return if storage open
+      # non-persisted cache values update next cycle
+      return if @storage_open
+
+      # open storage
+      @storage_open = true
+      storage_contents = {}
+      begin
+        # read storage
+        storage_contents = JSON.parse(File.read(Aromancer::Storage.storage_filepath))
+      rescue StandardError => e
+        @storage_open = false
+        FileUtils.rm(Aromancer::Storage.storage_filepath)
+        return
+      end
+
+      # update storage and cache
+      ([key] + @cache.keys.select{|k|
+        !@cache[k][:persisted]
+      }).each{|k|
+        storage_contents[k] = @cache[k][:value]
+        @cache[k][:persisted] = true
+      }
 
+      # write storage
       File.open(Aromancer::Storage.storage_filepath, "w+") do |f|
         f.write(storage_contents.to_json)
       end
+
+      # close storage
+      @storage_open = false
     end
   end
 end

data/lib/aromancer/version.rb

@@ -11,5 +11,5 @@
 =end
 
 module Aromancer
-  VERSION = "0.0.4"
+  VERSION = "0.0.6"
 end

data/lib/aromancer/websocket.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+=begin
+
+  websocket.rb
+
+  websocket client.
+
+  by i2097i
+
+=end
+
+module Aromancer
+  class Websocket
+    include Singleton
+
+    TYPES = [
+      :arena,
+      :legends,
+      :player # todo: not used
+    ]
+
+    attr_accessor :socket
+
+    def connect
+      return unless self.socket.nil?
+      return if Aromancer::Storage.get_player["api_key"].nil?
+
+      begin
+        self.socket = WebSocket::Client::Simple.connect(Aromancer::Storage.get_websocket_url, {headers: Aromancer::Server.auth_header})
+      rescue Socket::ResolutionError => e
+        disconnect
+        return
+      end
+      self.socket.on :message do |msg|
+        payload = JSON.parse(msg.data) rescue msg.data
+        if !payload.nil? &&
+          !payload["identifier"].nil? &&
+          !payload["message"].nil? &&
+          !payload["message"]["type"].nil? &&
+          TYPES.include?(payload["message"]["type"].to_sym)
+
+          case payload["message"]["type"].to_sym
+          when :arena
+            legend_id = payload["message"]["id"]
+            lid = Aromancer::Storage.get_player&.symbolize_keys[:active_legend_id]
+            if !lid.nil? && lid == legend_id.to_i
+              Aromancer::Api.load_arena
+              sleep(0.5)
+              Aromancer::Cli.instance.start_ui_thread
+            end
+          when :legends
+            Aromancer::Api.get_legends
+          when :player
+          end
+        end
+      end
+
+      self.socket.on :open do
+        r = {
+          command: "subscribe",
+          identifier: {channel: "PlayerChannel"}.to_json
+        }.to_json
+        Aromancer::Websocket.instance.socket.send(r)
+      end
+
+      self.socket.on :close do |e|
+        Aromancer::Websocket.instance.disconnect
+      end
+
+      self.socket.on :error do |e|
+        puts e.inspect
+        Aromancer::Websocket.instance.disconnect
+      end
+    end
+
+    def disconnect
+      self.socket&.close
+      self.socket = nil
+    end
+  end
+end

data/lib/aromancer.rb

@@ -14,8 +14,116 @@ require_relative :reiquire.to_s
 Reiquire::aromancer
 
 module Aromancer
+  THROTTLE_MS = 0.2
   FONT = TTY::Font.new(:standard)
 
+  UNICODE = {
+    close: "\u2A2F",
+    check: "\u2713"
+  }
+
+  # instance runs on main thread
+  class Cli
+    include Singleton
+
+    attr_accessor :ui_thread, :ws_thread, :busy, :last_render
+
+    # user entry point
+    def self.run
+      # ensure preferences exist
+      Aromancer::Storage.get_preference(:debug, default: false)
+      Aromancer::Storage.get_preference(:force_ssl, default: true)
+      Aromancer::Storage.get_preference(:hide_sentences, default: true)
+
+      self.instance.last_render = 0
+
+      # load player on-start
+      Aromancer::Api.set_active_legend_id(nil) unless Aromancer::Storage.get_player.nil?
+
+      Thread.main[:route] = :authentication
+      Thread.main[:menu_options] = {}
+      Aromancer::Prompt.say(I18n.t("shared.welcome", version: Aromancer::VERSION))
+      Aromancer::Prompt.say(I18n.t("shared.server_url", url: Aromancer::Storage::get_server_url))
+      self.instance.start_ui_thread
+      self.instance.start_ws_thread
+      loop do
+        begin
+          self.instance.ui_thread.join
+        rescue NoMethodError => e
+          if Aromancer::Storage.get_preference(:debug)
+            Aromancer::Prompt.say(I18n.t("shared.last_error"))
+            Aromancer::Prompt.say(e.inspect)
+            sleep(5)
+          end
+          self.instance.start_ui_thread
+          self.instance.start_ws_thread
+          sleep(1)
+        rescue Interrupt => e
+          exit
+        end
+      end
+    end
+
+    def get_view(view_key)
+      Thread.main[:menu_options][view_key.to_sym]
+    end
+
+    def start_ui_thread(force = false)
+      return if (@busy || Time.now - @last_render < 2) && !force
+
+      @busy = true
+      self.ui_thread&.exit
+      self.ui_thread&.kill
+      Thread.main[:menu_runners] = {}
+      Aromancer::Prompt.instance.reload!
+      self.ui_thread = Thread.new do
+        loop do
+          menu_options = Thread.main[:menu_options][Thread.main[:route]]
+          menu_runners = Thread.main[:menu_runners][Thread.main[:route]]
+          unless menu_options.nil? || menu_runners.nil?
+            Aromancer::Routes.resume
+            sleep(THROTTLE_MS)
+            Aromancer.print_hud
+            v = Aromancer::Prompt.p.select("", menu_options, show_help: :always, cycle: true, per_page: 11)
+            runners = menu_runners.select{|r| r[:value] == v}
+            runners = menu_runners.select{|r| r[:value].nil?} if runners.empty?
+
+            if runners.any?
+              r = runners.first
+              r[:proc].call(v)
+            else
+              exit
+            end
+          else
+            Aromancer::Routes.resume
+          end
+          Aromancer::Cli.instance.busy = false
+          Aromancer::Cli.instance.last_render = Time.now
+          # sleep(THROTTLE_MS)
+        end
+      end
+    end
+
+    def start_ws_thread
+      self.ws_thread.kill unless self.ws_thread.nil?
+      self.ws_thread = Thread.new do
+        Aromancer::Websocket.instance.disconnect
+        loop do
+          player = Aromancer::Storage.get_player
+          if player.nil?
+            Aromancer::Websocket.instance.disconnect
+          elsif !player["api_key"].nil?
+            # attempt websocket connection
+            Aromancer::Websocket.instance.connect
+          end
+
+          sleep(4)
+        end
+      end
+    end
+
+  end
+
   def self.get_font(text = :aromancer.to_s, letter_spacing = 1)
     Aromancer::FONT.write(text, letter_spacing: letter_spacing).split("\n")
   end
@@ -24,6 +132,19 @@ module Aromancer
     "#{`echo $HOME`.strip}/.aromancer"
   end
 
+  def self.print_hud
+    websocket_status = "#{Aromancer::Storage.instance.get_key(:websocket_scheme)}: #{Aromancer::Websocket.instance.socket.nil? ? UNICODE[:close] : UNICODE[:check] }"
+    player_status = if Aromancer::Storage.get_player.nil?
+      I18n.t("routes.main_menu.not_signed_in")
+    else
+      I18n.t("shared.signed_in_as", as: Aromancer::Storage.get_player["alias"])
+    end
+
+    Aromancer::Prompt.say(
+      [nil, player_status, websocket_status, nil].join(" | ")
+    )
+  end
+
   def self.print_last_error(i18n_key = nil)
     last_error = Aromancer::Storage.get_last_error
     return if last_error.nil?
@@ -35,6 +156,7 @@ module Aromancer
     rescue JSON::ParserError => e
       message = last_error[:body]
     end
-    Aromancer::Prompt.say(I18n.t(i18n_key, status: last_error[:status], error: message))
+    Aromancer::Prompt.say(I18n.t(i18n_key || "shared.last_error", status: last_error[:status], error: message))
+    Aromancer::Storage.set_last_error(nil)
   end
 end

data/lib/reiquire.rb

@@ -13,7 +13,7 @@ require :"active_support/all".to_s
 require :i18n.to_s
 require :faraday.to_s
 require :fileutils.to_s
-# require :"websocket-client-simple".to_s
+require :"websocket-client-simple".to_s
 
 # require :"tty-box".to_s # draw box shapes
 # require :"tty-color".to_s # detect color support

data/locale/en.yml

@@ -7,7 +7,13 @@ en:
     inturrupt: "exiting due to user inturrupt..."
     reader_initialized: "input reader initialized."
     welcome: "welcome to aromancer. loading v%{version}..."
+    server_url: "current server: %{url}"
     navigate: "navigate to %{route}."
+    update_cancel: "update cancelled."
+    update_confirm: "confirm update [%{new_value}] (enter y): "
+    signed_in_as: "authenticated as %{as}"
+    last_error: "error (%{status}). %{error}"
+    back: "back"
     exit: "exit"
   routes:
     authentication:
@@ -17,17 +23,31 @@ en:
       title: "authenticate"
       subtitle: ""
     main_menu:
+      configure: "configure"
       title: "main menu"
       subtitle: ""
       new_game: "new game"
       load_game: "load game"
+      find_game: "find game"
+      player_count: "enter player count (1-2): "
       sign_out: "sign out"
-      not_signed_in: "not signed in. invalid session. redirecting to authentication."
+      not_signed_in: "signed out"
+    configure:
+      title: "configure %{name}"
+      new_host: "enter new server host: "
+      new_port: "enter new server port: "
+      force_ssl_toggle: "ssl preference toggled to %{value}"
+      server_host: "host (%{stored})"
+      server_port: "port (%{stored})"
+      force_ssl: "ssl (%{stored})"
+      debug: "debug (%{stored})"
+      debug_toggle: "debug preference toggled to %{value}"
     new_game:
       player_count: "number of players"
       story_count: "number of stories"
       starting: "starting new game..."
       status: "status"
+      cancelled: "cancelled. game not created."
     legend:
       title: "legend"
       subtitle: "%{subtitle}"