aromancer 0.0.5 → 0.0.7

data/lib/aromancer/server.rb

@@ -14,8 +14,6 @@ module Aromancer
   class Server
     include Singleton
 
-    DEVELOP_SERVER_URL = "http://localhost:3000"
-
     HEADERS = { "Content-Type": "application/json" }
 
     class InternalError
@@ -35,10 +33,8 @@ module Aromancer
       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)
@@ -78,8 +74,7 @@ module Aromancer
       begin
         Faraday.new(
           url: Aromancer::Storage.get_server_url,
-          headers: HEADERS,
-          params: api_key_param
+          headers: HEADERS.merge(auth_header),
         ).delete("/session")
       rescue StandardError => e
         InternalError.build(e)
@@ -90,8 +85,8 @@ module Aromancer
       begin
         Faraday.new(
           url: Aromancer::Storage.get_server_url,
-          headers: HEADERS,
-          params: params.merge(api_key_param)
+          headers: HEADERS.merge(auth_header),
+          params: params
         ).post("/legends")
       rescue StandardError => e
         InternalError.build(e)
@@ -102,20 +97,30 @@ module Aromancer
       begin
         Faraday.new(
           url: Aromancer::Storage.get_server_url,
-          headers: HEADERS,
-          params: api_key_param
+          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: Aromancer::Storage.get_server_url,
-          headers: HEADERS,
-          params: params.merge(api_key_param)
+          headers: HEADERS.merge(auth_header),
+          params: params
         ).put("/players/#{Aromancer::Storage.get_player["id"]}")
       rescue StandardError => e
         InternalError.build(e)
@@ -123,67 +128,68 @@ 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: Aromancer::Storage.get_server_url,
-          headers: HEADERS,
-          params: api_key_param
+          headers: HEADERS.merge(auth_header),
         ).get("/legends/#{legend_id}/arena")
       rescue StandardError => e
         InternalError.build(e)
       end
     end
 
-    def self.get_stream
-      legend_id = Aromancer::Storage.get_player["active_legend_id"]
+    def self.get_stream(count = nil)
+      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: Aromancer::Storage.get_server_url,
-          headers: HEADERS,
-          params: api_key_param
-        ).get("/legends/#{legend_id}/stream")
+          headers: HEADERS.merge(auth_header),
+        ).get("/legends/#{legend_id}/stream?count=#{count || nil}")
       rescue StandardError => e
         InternalError.build(e)
       end
     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: Aromancer::Storage.get_server_url,
-          headers: HEADERS,
-          params: api_key_param
+          headers: HEADERS.merge(auth_header),
         ).get("/legends/#{legend_id}/words/#{selected_word_id}/possibilities")
       rescue StandardError => e
         InternalError.build(e)
       end
     end
 
-    def self.create_turn(params)
-      legend_id = Aromancer::Storage.get_player["active_legend_id"]
+    def self.submit_turn(request_uuid, params = {})
+      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: Aromancer::Storage.get_server_url,
-          headers: HEADERS,
-          params: params.merge(api_key_param)
-        ).post("/legends/#{legend_id}/arena")
+          headers: HEADERS.merge(auth_header),
+          params: params
+        ).put("/legends/#{legend_id}/arena/#{request_uuid}")
       rescue StandardError => e
         InternalError.build(e)
       end
     end
 
-    def self.update_turn(params)
-      legend_id = Aromancer::Storage.get_player["active_legend_id"]
+    def self.load_rules
       begin
         Faraday.new(
           url: Aromancer::Storage.get_server_url,
-          headers: HEADERS,
-          params: params.merge(api_key_param)
-        ).put("/legends/#{legend_id}/arena")
+          headers: HEADERS.merge(auth_header),
+        ).get("/")
       rescue StandardError => e
         InternalError.build(e)
       end

data/lib/aromancer/storage.rb

@@ -12,6 +12,8 @@ module Aromancer
   class Storage
     include Singleton
 
+    DEFAULT_SERVER = "http://127.0.0.1"
+
     attr_accessor :storage_open, :cache
 
     def initialize
@@ -46,7 +48,7 @@ module Aromancer
       return Time.now.to_i
     end
 
-    def self.get_preference(preference, default: :default)
+    def self.get_preference(preference, default: nil)
       p_key = "preference_#{preference}"
       p = instance.get_key(p_key)
       if p.nil?
@@ -61,8 +63,13 @@ module Aromancer
       instance.set_key(p_key, value)
     end
 
+    def self.toggle_preference(key)
+      v = get_preference(key)
+      set_preference(key, !v)
+    end
+
     def self.toggle_force_ssl
-      set_preference(:force_ssl, !get_preference(: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 : ""}")
@@ -124,17 +131,18 @@ module Aromancer
 
     def self.set_server_url(server_url)
       uri = URI.parse(server_url)
-      if uri.kind_of?(URI::HTTP) or uri.kind_of?(URI::HTTPS)
+      if uri.kind_of?(URI::HTTP) || 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)
         }
-      else
-        set_server_url(Aromancer::Server::DEVELOP_SERVER_URL)
+      elsif get_server_url.nil?
+        set_server_url(DEFAULT_SERVER)
       end
     end
 
     def self.get_server_url
-      set_server_url(Aromancer::Server::DEVELOP_SERVER_URL) if URI_KEYS.all?{|k| Aromancer::Storage.instance.get_key("server_url_#{k}").nil?}
+      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
@@ -187,16 +195,15 @@ module Aromancer
         FileUtils.rm(Aromancer::Storage.storage_filepath)
         return
       end
-      @storage_open = false
 
       # only update the cache value if present in storage
       if storage_contents.keys.include?(key)
-        @cache[key][:value] = storage_contents[key]
-        @cache[key][:persisted] = true
+        @cache[key] = {value: storage_contents[key], persisted: true}
       else
         @cache[key][:persisted] = false
       end
 
+      @storage_open = false
       @cache[key][:value]
     end
 

data/lib/aromancer/version.rb

@@ -11,5 +11,5 @@
 =end
 
 module Aromancer
-  VERSION = "0.0.5"
+  VERSION = "0.0.7"
 end

data/lib/aromancer/websocket.rb

@@ -16,14 +16,22 @@ module Aromancer
 
     TYPES = [
       :arena,
-      :player
+      :legends,
+      :player # todo: not used
     ]
 
     attr_accessor :socket
 
-    def connect(api_key)
+    def connect
       return unless self.socket.nil?
-      self.socket = WebSocket::Client::Simple.connect("#{Aromancer::Storage.get_websocket_url}?api_key=#{api_key}")
+      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? &&
@@ -32,10 +40,18 @@ module Aromancer
           !payload["message"]["type"].nil? &&
           TYPES.include?(payload["message"]["type"].to_sym)
 
-          legend_id = payload["message"]["id"]
-          lid = Aromancer::Storage.get_player&.symbolize_keys[:active_legend_id]
-          if !lid.nil? && lid == legend_id.to_i
-            Aromancer::Cli.instance.start_ui_thread
+          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
@@ -43,7 +59,7 @@ module Aromancer
       self.socket.on :open do
         r = {
           command: "subscribe",
-          identifier: {channel: "PlayerChannel", api_key: api_key}.to_json
+          identifier: {channel: "PlayerChannel"}.to_json
         }.to_json
         Aromancer::Websocket.instance.socket.send(r)
       end
@@ -59,7 +75,8 @@ module Aromancer
     end
 
     def disconnect
-      self.socket = nil unless self.socket.nil?
+      self.socket&.close
+      self.socket = nil
     end
   end
 end

data/lib/aromancer.rb

@@ -14,19 +14,51 @@ require_relative :reiquire.to_s
 Reiquire::aromancer
 
 module Aromancer
-  THROTTLE_MS = 0.4
+  THROTTLE_MS = 0.1
+  ERROR_EXPIRATION = 7.77.to_f
   FONT = TTY::Font.new(:standard)
+  DATE_FORMAT = "%A %d %b %Y %I:%M:%S %p"
+  TIME_FORMAT = "%I:%M:%S %p"
+
+  UNICODE = {
+    close: "\u2A2F",
+    check: "\u2713"
+  }
+
+  class Serve
+    def self.run
+      unless Dir.exist?("#{Aromancer.to_s.downcase}_serve")
+        system("git clone git@github.com:arowmancy/aromancer_serve.git")
+      end
+      FileUtils.chdir :aromancer_serve.to_s do
+        system("bin/setup")
+      end
+    end
+  end
 
   # instance runs on main thread
   class Cli
     include Singleton
 
-    attr_accessor :ui_thread, :ws_thread, :busy, :last_render
+    attr_accessor :ui_thread, :ws_thread, :busy, :ws_busy, :last_render, :error_timeout
 
     # 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)
+      Aromancer::Storage.get_preference(:hide_stream, default: true)
+
+      self.instance.last_render = 0
+      self.instance.error_timeout = Time.now.to_i
+
+      # load player on-start
+      Aromancer::Api.set_active_legend_id(nil) unless Aromancer::Storage.get_player.nil?
+
       Thread.main[:route] = :authentication
-      self.instance.last_render = Time.now
+      Thread.main[:menu_runners] = {}
+      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
@@ -35,70 +67,79 @@ module Aromancer
         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(JSON.pretty_generate(e[:body.to_s]))
+            Aromancer::Prompt.say("sleeping 5 on main thread...")
+            sleep(5)
+          end
           self.instance.start_ui_thread
+          self.instance.start_ws_thread
           sleep(1)
         rescue Interrupt => e
+          Aromancer::Prompt.say("interrupt on main thread...exiting immediately.")
           exit
         end
       end
     end
 
-    def start_ui_thread
-      if @busy || Time.now - @last_render < 2
-        # Thread.new{
-        #   while Aromancer::Cli.instance.busy do
-        #     if Time.now - Aromancer::Cli.instance.last_render > 5
-        #       sleep(2)
-        #       Aromancer::Cli.instance.start_ui_thread
-        #     end
-        #   end
-        # }.join
-        return
-      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.0) && !force
+
       @busy = true
       self.ui_thread&.exit
       self.ui_thread&.kill
-      Thread.main[:input_controls] = nil
+      Thread.main[:menu_runners] = {}
+      Thread.main[:menu_options] = {}
       Aromancer::Prompt.instance.reload!
       self.ui_thread = Thread.new do
         loop do
-          ic = Thread.main[:input_controls]
-          unless ic.nil?
+          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
+            Aromancer.print_hud
             sleep(THROTTLE_MS)
-            v = Aromancer::Prompt.p.select("", ic[:choices], show_help: :always, cycle: true, per_page: 11)
-            runners = ic[:runners].select{|r| r[:value] == v}
-            runners = ic[:runners].select{|r| r[:value].nil?} if runners.empty?
+            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)
+          sleep(THROTTLE_MS)
         end
       end
     end
 
     def start_ws_thread
+      return if @ws_busy
+      @ws_busy = true
       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?
+            @ws_busy = true
             Aromancer::Websocket.instance.disconnect
           elsif !player["api_key"].nil?
             # attempt websocket connection
-            # puts :ws_thread
-            Aromancer::Websocket.instance.connect(player["api_key"])
+            @ws_busy = true
+            Aromancer::Websocket.instance.connect
           end
-
+          @ws_busy = false
           sleep(4)
         end
       end
@@ -114,9 +155,38 @@ module Aromancer
     "#{`echo $HOME`.strip}/.aromancer"
   end
 
+  def self.date_display(raw)
+    DateTime.parse(raw)&.strftime(Aromancer::DATE_FORMAT).downcase.gsub(" ", "_")
+  end
+
+  def self.time_display(raw)
+    DateTime.parse(raw)&.strftime(Aromancer::TIME_FORMAT).downcase.gsub(" ", "_")
+  end
+
+  def self.print_hud
+    print_last_error
+    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, :v.to_s + Aromancer::VERSION, player_status, websocket_status, nil,].join(" | ")
+    )
+  end
+
   def self.print_last_error(i18n_key = nil)
+    if Time.now.to_f - Aromancer::Cli.instance.error_timeout.to_f >= Aromancer::ERROR_EXPIRATION
+      Aromancer::Cli.instance.error_timeout = Time.now.to_i
+      Aromancer::Storage.set_last_error(nil)
+      return
+    end
+
     last_error = Aromancer::Storage.get_last_error
     return if last_error.nil?
+
     last_error = last_error.symbolize_keys
     message = last_error[:body]
     begin
@@ -125,6 +195,13 @@ module Aromancer
     rescue JSON::ParserError => e
       message = last_error[:body]
     end
-    Aromancer::Prompt.say(I18n.t(i18n_key, status: last_error[:status], error: message))
+
+    if message.kind_of?(Hash)
+      message = JSON.pretty_generate(message)
+    elsif message.kind_of?(String)
+      message = message[0..777]
+    end
+
+    Aromancer::Prompt.say(I18n.t(i18n_key || "shared.last_error", status: last_error[:status], error: message), rjust: true)
   end
 end

data/locale/en.yml

@@ -11,6 +11,8 @@ en:
     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:
@@ -26,26 +28,31 @@ en:
       subtitle: ""
       new_game: "new game"
       load_game: "load game"
+      find_game: "find game"
+      rules: "rules"
       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: "force ssl preference toggled to %{value}"
+      force_ssl_toggle: "ssl preference toggled to %{value}"
       server_host: "host (%{stored})"
       server_port: "port (%{stored})"
-      force_ssl: "force ssl (%{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"
+      player_count: "players"
+      story_count: "stories"
       starting: "starting new game..."
       status: "status"
       cancelled: "cancelled. game not created."
     legend:
       title: "legend"
       subtitle: "%{subtitle}"
+      alchemy_for: "alchemy_for_%{name}:"
       arena_failed: "arena failed to load (%{status}). %{error}"
       scroll: "scroll"
       spoken_words: "scroll words"
@@ -61,6 +68,8 @@ en:
       place_on_scroll: "place %{word} on the scroll."
       options_for_word: "available options for the %{word} word."
       last_error: "last error"
+      returning_to_main: "returning to main menu..."
+      your_alchemy: "alchemy"
     legends:
       help: ""
     legend_menu:
@@ -69,5 +78,5 @@ en:
       help: ""
     stream:
       title: "stream"
-
-
+      end: "eos"
+      hide_title: "hide stream"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aromancer
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - i2097i
@@ -245,6 +245,8 @@ files:
 - checksums/aromancer-0.0.3.gem.sha512
 - checksums/aromancer-0.0.4.gem.sha512
 - checksums/aromancer-0.0.5.gem.sha512
+- checksums/aromancer-0.0.6.gem.sha512
+- checksums/aromancer-0.0.7.gem.sha512
 - gem_graph.png
 - lib/aromancer.rb
 - lib/aromancer/.DS_Store