aromancer 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ebbde2a81b320eab73f2035b03d5166c5bcec1c01eaef7e51e4a010a8ab8251
-  data.tar.gz: 044c185f6741090deb4e179c8716e35d23e1b6a775c42db683ee079db8cb1419
+  metadata.gz: da80d9c4f943470ac226c37651e21eaa5ee12128beb9c00264b43ace9845c61c
+  data.tar.gz: c55101847c0d3e6c14d7c821dc9fdf31d4e114d614d97957b7162ab995d5a02e
 SHA512:
-  metadata.gz: d992314e5e012369313167b145991a687ec0cfaa2a4e6b8ef445f147333e64e287eb70e9208215fac91b6ef20b04e0b3f740ee20ffd7f3c1b60197ad536dd4ad
-  data.tar.gz: 9210fd3030350a65b7f56ee68be13296a2707514f9cb1cf378e792b95868ad08c0009ec7c6c7409d6060919ee28911b557b4b4e673b933f47790b50ea2a46b4f
+  metadata.gz: 706112cc7fbf39edadef53eb6ac54a73c4e43d17f0f3b288cb9c795ba937bc38ec8427bb74ddcfbd8c84411483c520a8d9ac9b576f4371c1f0c656c2e36adb69
+  data.tar.gz: 91aa390ba4cf322eef5e616053cce00ebaba35ef0b9d13e051f2ba71a08bdf7c7ba5a9669d0279f88e7a67ed619a2cddba2b36f5eddc52854f691f2b74458fbc

data/CODE_OF_CONDUCT.md

@@ -7,4 +7,4 @@
 * When interpreting the words and actions of others, participants should always assume good intentions.
 * Behaviour which can be reasonably considered harassment will not be tolerated.
 
-If you have any concerns about behaviour within this project, please contact us at ["i2097i@hotmail.com"](mailto:"i2097i@hotmail.com").
+If you have any concerns about behavior within this project, please contact us at ["i2097i@hotmail.com"](mailto:"i2097i@hotmail.com").

data/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 i2097i
+Copyright (c) 2026 Scot Reichman
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -24,4 +24,4 @@ aromancer
 [license](http://opensource.org/licenses/MIT)
 [issues](https://github.com/i2097i/aromancer/issues)
 
-#### aromancer by i2097i is copyright (2026)
+#### aromancer by scot reichman is copyright (2026)

data/checksums/aromancer-0.0.8.gem.sha512

@@ -0,0 +1 @@
+ea42cb760ae909d4de2b750f3ca7f125d58b9e9147886927e8f5b7dd81a80913152d6052c1c517a99a0733e7d3b15de86d3083d1f82d5341e4c8f1e3364222a2

data/lib/aromancer/api.rb

@@ -24,23 +24,12 @@ module Aromancer
         body: response.body.to_s
       }
       Aromancer::Storage.set_last_error(le)
-      Aromancer.print_last_error
-      signed_out = false
-      signed_out = response.status == 401
-      # error_body = nil
-      # begin
-      #   error_body = JSON.parse(response.body)
-      # rescue StandardError => e
-      # end
-
-      # signed_out = signed_out &&
-      #   !error_body.nil? &&
-      #   error_body.keys.include?(:error_message.to_s) &&
-      #   error_body["error_message"] == "not signed in"
-
-      if signed_out
-        Aromancer::Storage.instance.clear_cache!
-        Aromancer::Storage.set_signed_out_flag(signed_out)
+
+      if response.status == 401
+        Aromancer::Storage.set_signed_out_flag(true)
+        player = Aromancer::Storage.get_player
+        player["api_key"] = nil
+        Aromancer::Storage.set_player(player)
       end
     end
 
@@ -93,17 +82,9 @@ module Aromancer
 
     def self.sign_out
       result = Aromancer::Server.sign_out
-      # clear storage
-      Aromancer::Storage.instance.clear_cache!
-      Aromancer::Storage.set_signed_out_flag(false)
       Aromancer::Storage.set_player(nil)
-      Aromancer::Storage.set_legends(nil)
-      Aromancer::Storage.set_arena(nil)
-      Aromancer::Storage.set_stream(nil)
-      Aromancer::Storage.set_last_error(nil)
-
       Aromancer::Websocket.instance.disconnect
-
+      Aromancer::Storage.recreate!
       register_error(result) if result.status != 200
     end
 

data/lib/aromancer/cli.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+=begin
+
+  cli.rb
+
+  aromancer cli
+
+  by i2097i
+
+=end
+
+module Aromancer
+  # instance runs on main thread
+  class Cli
+    include Singleton
+
+    attr_accessor :ui_thread, :ws_thread, :ui_busy, :ws_busy, :last_render, :error_timeout
+
+    THROTTLE_MS = 0.1
+
+    # user entry point
+    def self.run
+      Aromancer::Websocket.instance
+      Aromancer::Storage.instance
+
+      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
+      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
+      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(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(force = false)
+      return if (@ui_busy || Time.now - @last_render < 2.0) && !force
+
+      @ui_busy = true
+      self.ui_thread&.exit
+      self.ui_thread&.kill
+      Thread.main[:menu_runners] = {}
+      Thread.main[:menu_options] = {}
+      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? ||
+            menu_options.empty? ||
+            menu_runners.empty?
+
+            Aromancer::Routes.resume
+            sleep(THROTTLE_MS)
+            Aromancer.print_hud
+
+            v = Aromancer::Prompt.p.select("", menu_options, show_help: :always, cycle: true, per_page: 11)
+            Aromancer.print_hud
+            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)
+            end
+
+          else
+            sleep(THROTTLE_MS)
+            Aromancer::Routes.resume
+          end
+          Aromancer::Cli.instance.ui_busy = false
+          Aromancer::Cli.instance.last_render = Time.now
+          sleep(THROTTLE_MS)
+        end
+      end
+    end
+
+    def start_ws_thread
+      return if @ws_busy
+      @ws_busy = true
+      self.ws_thread&.exit
+      self.ws_thread&.kill
+      self.ws_thread = Thread.new do
+        Aromancer::Websocket.instance.disconnect
+        loop do
+          player = Aromancer::Storage.get_player
+          if player.nil? ||
+            player["active_legend_id"].nil?
+            @ws_busy = true
+            Aromancer::Websocket.instance.disconnect
+          elsif !player["api_key"].nil? &&
+            !player["active_legend_id"].nil? &&
+            (Aromancer::Websocket.instance.socket.nil? || Aromancer::Websocket.instance.socket.closed?)
+            # attempt websocket connection
+            @ws_busy = true
+            Aromancer::Websocket.instance.connect
+            if Aromancer::Storage.get_arena.nil?
+              Aromancer::Api.load_arena
+              sleep(1)
+              Aromancer::Cli.instance.start_ui_thread(true)
+            end
+          end
+          @ws_busy = false
+          sleep(1)
+        end
+      end
+    end
+  end
+end

data/lib/aromancer/routes.rb

@@ -46,24 +46,10 @@ module Aromancer
       ).first
     end
 
-    def self.arena_data
-      arena = Aromancer::Storage.get_arena
-      if arena.nil?
-        Aromancer::Api.load_arena
-        sleep(1)
-      end
-
-      if arena.nil?
-        Aromancer.print_last_error("routes.legend.arena_failed")
-        Aromancer::Prompt.p.ask(I18n.t("shared.key_press"))
-        Aromancer::Api.set_active_legend_id(nil)
-      else
-        arena
-      end
-    end
-
     def self.authentication
-      if Aromancer::Storage.get_player
+      unless Aromancer::Storage.get_player.nil? ||
+        Aromancer::Storage.get_player["api_key"].nil?
+
         Aromancer::Storage.set_signed_out_flag(false)
         return main_menu
       end
@@ -87,6 +73,9 @@ module Aromancer
         }},
         {value: :configure, proc: Proc.new{
           configure
+        }},
+        {value: :exit, proc: Proc.new{
+          exit
         }}
       ]
       Thread.main[:route] = __method__.to_sym
@@ -94,7 +83,7 @@ module Aromancer
 
     def self.configure
       cls
-
+      Aromancer.print_large_text(Thread.main[:route].to_s)
       Aromancer::Prompt.say(I18n.t("routes.configure.title", name: Aromancer.to_s.downcase))
       [
         Aromancer::Storage.get_server_url,
@@ -210,6 +199,7 @@ module Aromancer
 
       return authentication if player.nil?
 
+      Aromancer.print_large_text
       Thread.main[:menu_options][__method__.to_sym] ||= [
         {name: I18n.t("routes.main_menu.new_game"), value: :new},
         {name: I18n.t("routes.main_menu.load_game"), value: :load},
@@ -252,7 +242,7 @@ module Aromancer
         }},
         {value: :exit, proc: Proc.new{
           exit
-        }},
+        }}
       ]
       Thread.main[:route] = __method__.to_sym
     end
@@ -277,18 +267,8 @@ module Aromancer
       ]
       Thread.main[:menu_runners][__method__.to_sym] = [
         {value: :continue, proc: Proc.new{
-          Aromancer::Storage.instance.clear_cache!
           Aromancer::Api.create_legend(params)
           legend_menu
-          # Aromancer::Api.get_legends
-
-          # unless active_legend.nil? || active_legend["id"] != Aromancer::Storage.get_player["active_legend_id"]
-          #   Aromancer.print_last_error
-          #   sleep(1)
-          #   main_menu
-          # else
-          #   legend_menu
-          # end
         }},
         {value: :cancel, proc: Proc.new{
           Aromancer::Prompt.say(I18n.t("routes.new_game.cancelled"))
@@ -306,7 +286,6 @@ module Aromancer
 
       # if legend_array.nil?, load player's legends
       if legend_array.nil?
-        Aromancer::Storage.instance.clear_cache!
         Aromancer::Api.get_legends
         legend_array = Aromancer::Storage.get_legends
         unless legend_array.any?
@@ -328,20 +307,19 @@ module Aromancer
       end
 
       Thread.main[:menu_runners][__method__.to_sym] = [
-        {value: :back, proc: Proc.new{ main_menu }},
+        {value: :back, proc: Proc.new{
+          Aromancer::Api.set_active_legend_id(nil)
+          main_menu
+        }},
       ] + legend_array.map{|l|
         {
           value: l["id"],
           proc: Proc.new{
             Aromancer::Api.set_active_legend_id(l["id"])
+            sleep(1)
+            Aromancer::Api.get_legends
 
-            unless active_legend.nil? || active_legend["id"] != Aromancer::Storage.get_player["active_legend_id"]
-              Aromancer.print_last_error
-              sleep(1)
-              main_menu
-            else
-              legend_menu
-            end
+            legend_menu
           }
         }
       }
@@ -370,61 +348,80 @@ module Aromancer
 
     def self.legend_menu
       cls
-      legend
-
-      legend_array = Aromancer::Storage.get_legends
       al = active_legend
-      if !al.nil?
-        if al["status"] == "complete"
+      al_status = ((al || {})["status"] || "").to_sym
+      arena = Aromancer::Storage.get_arena
+      if !al_status.nil? &&
+        ![:started, :paused].include?(al_status) &&
+        !al.nil? &&
+        !arena.nil?
+
+        stream(display_only: true) # display entire stream
+        Aromancer::Prompt.print_divider(al["value_display"])
+        Aromancer::Prompt.say(arena["title"])
+        Aromancer::Prompt.say(arena["players"].map{|p| "#{p["alias"]}(#{p["status"]}): #{p["score"]}"}.join(" | "))
+        Thread.main[:route] = __method__.to_sym
+        case al_status
+        when :created
+          Aromancer::Api.get_legends
+
           Thread.main[:menu_options][__method__.to_sym] = [
             {name: I18n.t("shared.key_press"), value: :key_press}
           ]
           Thread.main[:menu_runners][__method__.to_sym] = [
             {value: :key_press, proc: Proc.new{
-              Aromancer::Prompt.say(I18n.t("routes.legend.returning_to_main"))
+              Aromancer::Prompt.say(I18n.t("routes.legend.returning_to_", route: :legends))
               Aromancer::Api.set_active_legend_id(nil)
+              sleep(1)
               legends
             }}
           ]
-          Thread.main[:route] = __method__.to_sym
-          return
-        elsif al["status"] == "created"
+        when :complete
           Thread.main[:menu_options][__method__.to_sym] = [
-            {name: :reload, value: :reload}, {name: I18n.t("shared.back"), value: :back}
+            {name: I18n.t("shared.key_press"), value: :key_press}
           ]
           Thread.main[:menu_runners][__method__.to_sym] = [
-            {value: :reload, proc: Proc.new{ legend_menu }},
-            {value: :back, proc: Proc.new{
+            {value: :key_press, proc: Proc.new{
+              Aromancer::Prompt.say(I18n.t("routes.legend.returning_to_", route: :legends))
               Aromancer::Api.set_active_legend_id(nil)
               legends
             }}
           ]
-          Thread.main[:route] = __method__.to_sym
-          return
-        elsif active_legend["player"] && (active_legend["player"]["words"] || []).count == 0
-          Aromancer::Api.load_arena
-          return
         end
-      else
-        Thread.main[:menu_runners] = {}
-        Thread.main[:menu_options] = {}
-        Thread.main[:route] = :main_menu
+        return
+      end
+
+      arena = Aromancer::Storage.get_arena
+      if arena.nil? || arena["turn_player"].nil?
+        Aromancer::Prompt.say(I18n.t("shared.waiting"))
+        Thread.main[:menu_options][__method__.to_sym] = []
+        Thread.main[:menu_runners][__method__.to_sym] = []
+        sleep(1)
+        Aromancer::Api.get_legends
+        Aromancer::Api.load_arena
+        return
       end
 
+      legend
+
+      Thread.main[:route] = __method__.to_sym
+
       hide_sentences_pref = Aromancer::Storage.get_preference(:hide_sentences)
       hide_sentences_pref_value = "#{hide_sentences_pref ? "" : "hide_"}signed_sentences".to_sym
       hide_stream_pref = Aromancer::Storage.get_preference(:hide_stream)
       hide_stream_pref_value = "#{hide_stream_pref ? "" : "hide_"}title".to_sym
-
-      Thread.main[:route] = __method__.to_sym
       Thread.main[:menu_options][__method__.to_sym] = [
-        {name: I18n.t("routes.legend.unspoken_words"), value: :words},
-        {name: I18n.t("routes.legend.spoken_words"), value: :spoken_words},
-        {name: I18n.t("routes.legend.unsigned_sentences"), value: :unsigned_sentences},
         {name: I18n.t("routes.legend.#{hide_sentences_pref_value}"), value: hide_sentences_pref_value},
         {name: I18n.t("routes.stream.#{hide_stream_pref_value}"), value: hide_stream_pref_value},
         {name: I18n.t("routes.main_menu.title"), value: :main_menu}
       ]
+      if arena["turn_player"]["id"] == Aromancer::Storage.get_player["id"]
+        [
+          {name: I18n.t("routes.legend.unspoken_words"), value: :words},
+          {name: I18n.t("routes.legend.spoken_words"), value: :spoken_words},
+          {name: I18n.t("routes.legend.unsigned_sentences"), value: :unsigned_sentences}
+        ].reverse.each{|mo| Thread.main[:menu_options][__method__.to_sym].insert(0, mo)}
+      end
 
       Thread.main[:menu_runners][__method__.to_sym] = [
         {value: :words, proc: Proc.new{ words }},
@@ -447,48 +444,7 @@ module Aromancer
 
     def self.legend
       Aromancer::Prompt.say(I18n.t("shared.navigate", route: :legend)) if Aromancer::Storage.get_preference(:debug)
-      Aromancer::Api.load_arena
-      arena = arena_data
-      al = active_legend
-      al_status = ((al || {})["status"] || "").to_sym
-      if !al.nil? &&
-        [:created, :complete].include?(al_status)
-
-        stream(display_only: true) # display entire stream
-        Aromancer::Prompt.print_divider(al["value_display"])
-        Aromancer::Prompt.say(arena["title"])
-        Aromancer::Prompt.say(arena["players"].map{|p| "#{p["alias"]}(#{p["score"]})"}.join(" | "))
-
-        if al_status == :complete
-          Thread.main[:menu_options][:legend_menu] = [
-            {name: I18n.t("shared.key_press"), value: :key_press}
-          ]
-          Thread.main[:menu_runners][:legend_menu] = [
-            {value: :key_press, proc: Proc.new{
-              Aromancer::Prompt.say(I18n.t("routes.legend.returning_to_main"))
-              Aromancer::Api.set_active_legend_id(nil)
-              legends
-            }}
-          ]
-        else
-          Aromancer::Api.get_legends
-
-          Thread.main[:menu_options][:legend_menu] = [
-            {name: I18n.t("shared.back"), value: :back},
-            {name: I18n.t("shared.key_press"), value: :key_press}
-          ]
-          Thread.main[:menu_runners][:legend_menu] = [
-            {value: :back, proc: Proc.new{
-              Aromancer::Prompt.say(I18n.t("routes.legend.returning_to_main"))
-              Aromancer::Api.set_active_legend_id(nil)
-              legends
-            }},
-            {value: :key_press, proc: Proc.new{ legend_menu }}
-          ]
-        end
-        return
-      end
-
+      arena = Aromancer::Storage.get_arena
       return if arena.nil? || arena["turn_player"].nil?
 
       turn_player = arena["turn_player"]
@@ -578,7 +534,12 @@ module Aromancer
       cls
       legend
 
-      arena = arena_data
+      arena = Aromancer::Storage.get_arena
+      if arena["player"].nil? || arena["player"]["words"].nil?
+        Aromancer::Api.load_arena
+        sleep(1)
+        main_menu
+      end
       Thread.main[:menu_options][__method__.to_sym] = [
         {name: I18n.t("shared.back"), value: :back}
       ] + arena["player"]["words"].map{|w| {name: w["value_display"], value: w["id"]}}
@@ -597,7 +558,7 @@ module Aromancer
       cls
       legend
 
-      arena = arena_data
+      arena = Aromancer::Storage.get_arena
       Thread.main[:menu_options][__method__.to_sym] = [
         {name: I18n.t("shared.back"), value: :back}
       ] + arena["scroll_words"].map{|w| {name: w["value_display"], value: w["id"]}}
@@ -616,7 +577,7 @@ module Aromancer
       cls
       legend
 
-      arena = arena_data
+      arena = Aromancer::Storage.get_arena
       Thread.main[:menu_options][__method__.to_sym] = [
         {name: I18n.t("shared.back"), value: :back}
       ] + arena["sentences"].map{|s| {name: s["value_display"], value: s["id"]}}
@@ -646,11 +607,12 @@ module Aromancer
       selected_word = possibilities["word"]
       for_type = possibilities["for_type"].to_sym
 
-      arena = arena_data
+      arena = Aromancer::Storage.get_arena
       player_words = arena["player"]["words"]
 
       choices = [{name: I18n.t("shared.back"), value: :back}]
-      if for_type == :player_word
+      if for_type == :player_word &&
+        arena["turn_player"]["id"] == Aromancer::Storage.get_player["id"]
 
         # show place on scroll option if selected word is from player's words
         choices << {
@@ -659,8 +621,11 @@ module Aromancer
         }
       end
 
-      choices += options.map{|o| {name: "#{o["humanized_title"]} -> weight: #{o["total_weight"]}", value: o}}
+      unless arena["turn_player"]["id"] != Aromancer::Storage.get_player["id"]
+        choices += options.map{|o| {name: "#{o["humanized_title"]} -> weight: #{o["total_weight"]}", value: o}}
+      end
 
+      _muh_method = __method__.to_sym
       Thread.main[:menu_options][__method__.to_sym] = choices
       Thread.main[:menu_runners][__method__.to_sym] = [
         {value: :back, proc: Proc.new{
@@ -674,12 +639,24 @@ module Aromancer
           end
         }},
         {value: :player_word, proc: Proc.new{
+          Aromancer::Prompt.say(I18n.t("shared.waiting"))
+          Thread.main[:menu_options][_muh_method] = []
+          Thread.main[:menu_runners][_muh_method] = []
           Aromancer::Api.submit_turn(request_uuid)
-          legend_menu
+          # websockets will trigger this for other player after turn is submitted
+          Aromancer::Api.get_legends
+          Aromancer::Api.load_arena
+          sleep(1)
         }},
         {value: nil, proc: Proc.new{|o|
+          Aromancer::Prompt.say(I18n.t("shared.waiting"))
+          Thread.main[:menu_options][_muh_method] = []
+          Thread.main[:menu_runners][_muh_method] = []
           Aromancer::Api.submit_turn(request_uuid, {option_uuid: o[:uuid.to_s]})
-          legend_menu
+          # websockets will trigger this for other player after turn is submitted
+          Aromancer::Api.get_legends
+          Aromancer::Api.load_arena
+          sleep(1)
         }}
       ]
       Thread.main[:route_params] = [selected_word_id]

data/lib/aromancer/serve.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+=begin
+
+  serve.rb
+
+  aromancer serve functionality.
+
+  by i2097i
+
+=end
+
+module Aromancer
+  class Serve
+    SERVER_NAME = :"#{Aromancer.to_s.downcase}_serve".to_s
+
+    def self.run
+      unless Dir.exist?(serve_dir)
+        system(:"git clone git@github.com:arowmancy/#{SERVER_NAME}.git #{serve_dir}".to_s)
+      end
+      FileUtils.chdir serve_dir do
+        branch = "v#{Aromancer::VERSION}"
+        system(:"git checkout #{branch}".to_s)
+        system(:"git pull origin #{branch}".to_s)
+        system(:"bin/setup".to_s)
+      end
+    end
+
+    private
+
+    def self.serve_dir
+      File.join(Aromancer.home_directory, SERVER_NAME)
+    end
+  end
+end

data/lib/aromancer/server.rb

@@ -22,7 +22,6 @@ module Aromancer
       def initialize(status: -1, body: {})
         @status = status
         @body = body
-        Aromancer::Storage.instance.clear_cache!
       end
 
       def self.build(e)

data/lib/aromancer/storage.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 =begin
 
   storage.rb
@@ -12,18 +14,116 @@ module Aromancer
   class Storage
     include Singleton
 
+    VALID_KEYS = [
+      :arena,
+      :last_error,
+      :legends,
+      :player,
+      :preference_debug,
+      :preference_force_ssl,
+      :preference_hide_sentences,
+      :preference_hide_stream,
+      :server_url_host,
+      :server_url_port,
+      :server_url_scheme,
+      :signed_out_flag,
+      :stream,
+      :websocket_path,
+      :websocket_scheme
+   ]
+
+   PERSISTED_KEYS = [
+      :last_error,
+      :player,
+      :preference_debug,
+      :preference_force_ssl,
+      :preference_hide_sentences,
+      :preference_hide_stream,
+      :server_url_host,
+      :server_url_port,
+      :server_url_scheme,
+      :websocket_path,
+      :websocket_scheme
+    ]
+
+    URI_KEYS = [
+      :scheme,
+      :host,
+      :port
+    ]
+
     DEFAULT_SERVER = "http://127.0.0.1"
 
-    attr_accessor :storage_open, :cache
+    DEFAULT_PREFERENCES = {
+      preference_debug: false,
+      preference_force_ssl: false,
+      preference_hide_sentences: true,
+      preference_hide_stream: true,
+    }
+
+    attr_accessor :storage_open, :cache, :clear_flag, :parser_error
 
     def initialize
+      reload!
+      ensure_default_preferences_exist
+    end
+
+    def ensure_default_preferences_exist
+      DEFAULT_PREFERENCES.keys.each{|d_key|
+        current_value = get_key(d_key)
+        if current_value.nil? || ![TrueClass, FalseClass].include?(current_value.class)
+          set_key(d_key.to_s, DEFAULT_PREFERENCES[d_key])
+        end
+      }
+    end
+
+    def reload!
+      @storage_open = false
+      @clear_flag = false
+      @parser_error = nil
       clear_cache!
       FileUtils.mkdir_p(Aromancer.home_directory)
     end
 
     def clear_cache!
+      if @storage_open
+        @clear_flag = true
+        return
+      end
+      @clear_flag = false
       @storage_open = false
-      @cache = {}
+
+      @cache = {} # clear'd
+    end
+
+    def self.snapshot_config
+      current_config = {}
+
+      PERSISTED_KEYS.each{|p_key|
+        current_config[p_key] = Aromancer::Storage.instance.get_key(p_key)
+      }
+
+      current_config
+    end
+
+    def self.valid_config?(config)
+      return false unless config.kind_of?(Hash)
+
+      config.keys.all?{|k| PERSISTED_KEYS.include?(k.to_sym)}
+    end
+
+    def self.restore_config(config)
+      return nil unless valid_config?(config)
+      PERSISTED_KEYS.each{|p_key|
+        Aromancer::Storage.instance.set_key(p_key, config[p_key])
+      }
+    end
+
+    def self.recreate!
+      current_config = snapshot_config
+      FileUtils.rm_rf(storage_filepath)
+      Aromancer::Storage.instance.reload!
+      restore_config(current_config)
     end
 
     def self.storage_filepath
@@ -50,33 +150,33 @@ module Aromancer
 
     def self.get_preference(preference, default: nil)
       p_key = "preference_#{preference}"
-      p = instance.get_key(p_key)
-      if p.nil?
-        instance.set_key(p_key, default)
-        return instance.get_key(p_key)
+      pref = Aromancer::Storage.instance.get_key(p_key)
+      if pref.nil? && !default.nil?
+        Aromancer::Storage.instance.set_key(p_key, default)
+        pref = Aromancer::Storage.instance.get_key(p_key)
       end
-      p
+      pref
     end
 
     def self.set_preference(preference, value)
       p_key = "preference_#{preference}"
-      instance.set_key(p_key, value)
+      Aromancer::Storage.instance.set_key(p_key, value)
     end
 
     def self.toggle_preference(key)
-      v = get_preference(key)
+      v = get_preference(key, default: DEFAULT_PREFERENCES["preference_#{key}"])
       set_preference(key, !v)
     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 : ""}")
+      Aromancer::Storage.set_key(:server_url_scheme, "http#{v ? :s : ""}")
+      Aromancer::Storage.set_key(:websocket_scheme, "ws#{v ? :s : ""}")
     end
 
     def self.set_signed_out_flag(flag)
-      Aromancer::Storage.instance.set_key(:signed_out_flag, flag)
+      instance.set_key(:signed_out_flag, flag)
     end
 
     def self.get_signed_out_flag
@@ -84,7 +184,7 @@ module Aromancer
     end
 
     def self.set_player(player_hash)
-      Aromancer::Storage.instance.set_key(:player, player_hash)
+      instance.set_key(:player, player_hash)
     end
 
     def self.get_player
@@ -92,7 +192,7 @@ module Aromancer
     end
 
     def self.set_legends(legends_array)
-      Aromancer::Storage.instance.set_key(:legends, legends_array)
+      instance.set_key(:legends, legends_array)
     end
 
     def self.get_legends
@@ -100,7 +200,7 @@ module Aromancer
     end
 
     def self.set_arena(arena_hash)
-      Aromancer::Storage.instance.set_key(:arena, arena_hash)
+      instance.set_key(:arena, arena_hash)
     end
 
     def self.get_arena
@@ -108,7 +208,7 @@ module Aromancer
     end
 
     def self.set_stream(stream_array)
-      Aromancer::Storage.instance.set_key(:stream, stream_array)
+      instance.set_key(:stream, stream_array)
     end
 
     def self.get_stream
@@ -116,25 +216,18 @@ module Aromancer
     end
 
     def self.set_last_error(error_hash)
-      Aromancer::Storage.instance.set_key(:last_error, error_hash)
+      instance.set_key(:last_error, error_hash)
     end
 
     def self.get_last_error
       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) || 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)
+          instance.set_key("server_url_#{k}", uri.select(k).first)
         }
       elsif get_server_url.nil?
         set_server_url(DEFAULT_SERVER)
@@ -159,12 +252,12 @@ module Aromancer
     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?
+      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?
+      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
@@ -180,7 +273,9 @@ module Aromancer
 
       # ensure default for key exists
       @cache[key] = {value: nil, persisted: false} unless @cache.keys.include?(key)
-
+      if false && (@cache[:preference_debug.to_s] || {value: DEFAULT_PREFERENCES[:preference_debug]})[:value]
+        Aromancer::Prompt.say("#{__method__} > @cache[#{key}]=#{@cache[key]}")
+      end
       # return cache value if storage open or the cache value is persisted
       return @cache[key][:value] if @storage_open || @cache[key][:persisted]
 
@@ -188,12 +283,17 @@ module Aromancer
       @storage_open = true
       storage_contents = {}
       begin
+        @parser_error = nil
         # read storage
-        storage_contents = JSON.parse(File.read(Aromancer::Storage.storage_filepath))
+        storage_contents = JSON.parse(File.read(Aromancer::Storage.storage_filepath, encoding: "UTF-8"))
       rescue StandardError => e
         @storage_open = false
-        FileUtils.rm(Aromancer::Storage.storage_filepath)
-        return
+        if @parser_error.nil?
+          @parser_error = e
+          return get_key(key)
+        else
+          raise @parser_error
+        end
       end
 
       # only update the cache value if present in storage
@@ -203,20 +303,26 @@ module Aromancer
         @cache[key][:persisted] = false
       end
 
+      value = @cache[key][:value]
       @storage_open = false
-      @cache[key][:value]
+      clear_cache! if @clear_flag
+      return value
     end
 
     def set_key(key, value)
       key = key.to_s
 
       # ensure default for key exists
-      @cache[key] = {value: nil, persisted: false} unless @cache.keys.include?(key)
+      @cache[key] = {value: value, persisted: false} unless @cache.keys.include?(key)
 
       # assign new cache value and set persisted to false
       @cache[key][:value] = value
       @cache[key][:persisted] = false
 
+      if @storage_open && (@cache[:preference_debug.to_s] || {value: DEFAULT_PREFERENCES[:preference_debug]})[:value]
+        puts Thread.current.backtrace
+        Aromancer::Prompt.say("#{__method__} > @cache[#{key}]=#{@cache[key]}")
+      end
       # return if storage open
       # non-persisted cache values update next cycle
       return if @storage_open
@@ -225,12 +331,17 @@ module Aromancer
       @storage_open = true
       storage_contents = {}
       begin
+        @parser_error = nil
         # read storage
-        storage_contents = JSON.parse(File.read(Aromancer::Storage.storage_filepath))
+        storage_contents = JSON.parse(File.read(Aromancer::Storage.storage_filepath, encoding: "UTF-8"))
       rescue StandardError => e
         @storage_open = false
-        FileUtils.rm(Aromancer::Storage.storage_filepath)
-        return
+        if @parser_error.nil?
+          @parser_error = e
+          return get_key(key)
+        else
+          raise @parser_error
+        end
       end
 
       # update storage and cache
@@ -246,8 +357,13 @@ module Aromancer
         f.write(storage_contents.to_json)
       end
 
+      if (@cache[:preference_debug.to_s] || {value: DEFAULT_PREFERENCES[:preference_debug]})[:value]
+        Aromancer::Prompt.say("#{__method__} > @cache[#{key}]=#{@cache[key]}")
+      end
+
       # close storage
       @storage_open = false
+      clear_cache! if @clear_flag
     end
   end
 end

data/lib/aromancer/version.rb

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

data/lib/aromancer/websocket.rb

@@ -22,9 +22,18 @@ module Aromancer
 
     attr_accessor :socket
 
+    def self.channel_identifier
+      {identifier: {channel: :PlayerChannel.to_s, id: Aromancer::Storage.get_player["id"]}.to_json}
+    end
+
     def connect
-      return unless self.socket.nil?
-      return if Aromancer::Storage.get_player["api_key"].nil?
+      if !self.socket.nil? && self.socket.closed?
+        disconnect
+      end
+
+      return if !self.socket.nil? ||
+        Aromancer::Storage.get_player["api_key"].nil? ||
+        Aromancer::Storage.get_player["active_legend_id"].nil?
 
       begin
         self.socket = WebSocket::Client::Simple.connect(Aromancer::Storage.get_websocket_url, {headers: Aromancer::Server.auth_header})
@@ -45,8 +54,10 @@ module Aromancer
             legend_id = payload["message"]["id"]
             lid = Aromancer::Storage.get_player&.symbolize_keys[:active_legend_id]
             if !lid.nil? && lid == legend_id.to_i
+              Aromancer::Storage.instance.clear_cache!
+              Aromancer::Api.get_legends
               Aromancer::Api.load_arena
-              sleep(0.5)
+              sleep(1)
               Aromancer::Cli.instance.start_ui_thread
             end
           when :legends
@@ -57,10 +68,7 @@ module Aromancer
       end
 
       self.socket.on :open do
-        r = {
-          command: "subscribe",
-          identifier: {channel: "PlayerChannel"}.to_json
-        }.to_json
+        r = {"command": :subscribe.to_s}.merge(Aromancer::Websocket.channel_identifier).to_json
         Aromancer::Websocket.instance.socket.send(r)
       end
 
@@ -69,7 +77,10 @@ module Aromancer
       end
 
       self.socket.on :error do |e|
-        puts e.inspect
+        if Aromancer::Storage.get_preference(:debug)
+          Aromancer::Prompt.say("#{self.class.name} socket.on :error")
+          Aromancer::Prompt.say(e.inspect)
+        end
         Aromancer::Websocket.instance.disconnect
       end
     end
@@ -78,5 +89,15 @@ module Aromancer
       self.socket&.close
       self.socket = nil
     end
+
+    # todo: websockets only in-game
+    # https://docs.anycable.io/misc/action_cable_protocol#perform-actions
+    # def self.set_active_legend_id(id)
+    #   return if self.instance.socket.nil?
+    #   r = {"command": :message.to_s}.merge(Aromancer::Websocket.channel_identifier).merge({
+    #     data: {action: :player.to_s, active_legend_id: id}.to_json
+    #   }).to_json
+    #   self.instance.socket.send(r)
+    # end
   end
 end

data/lib/aromancer.rb

@@ -14,8 +14,7 @@ require_relative :reiquire.to_s
 Reiquire::aromancer
 
 module Aromancer
-  THROTTLE_MS = 0.1
-  ERROR_EXPIRATION = 7.77.to_f
+  ERROR_EXPIRATION = 11.11.to_f
   FONT = TTY::Font.new(:standard)
   DATE_FORMAT = "%A %d %b %Y %I:%M:%S %p"
   TIME_FORMAT = "%I:%M:%S %p"
@@ -25,130 +24,8 @@ module Aromancer
     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, :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
-      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
-      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(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 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[:menu_runners] = {}
-      Thread.main[:menu_options] = {}
-      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
-            Aromancer.print_hud
-            sleep(THROTTLE_MS)
-            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)
-            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
-      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
-            @ws_busy = true
-            Aromancer::Websocket.instance.connect
-          end
-          @ws_busy = false
-          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")
+  def self.print_large_text(text = Aromancer.to_s.downcase, letter_spacing = 1)
+    Aromancer::Prompt.say(Aromancer::FONT.write(text, letter_spacing: letter_spacing))
   end
 
   def self.home_directory
@@ -165,7 +42,10 @@ module Aromancer
 
   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] }"
+    ws_status_symbol = (
+      Aromancer::Websocket.instance.socket.nil? || Aromancer::Websocket.instance.socket.closed?
+    ) ? UNICODE[:close] : UNICODE[:check]
+    websocket_status = "#{Aromancer::Storage.instance.get_key(:websocket_scheme)}: #{ws_status_symbol}"
     player_status = if Aromancer::Storage.get_player.nil?
       I18n.t("routes.main_menu.not_signed_in")
     else
@@ -184,14 +64,15 @@ module Aromancer
       return
     end
 
-    last_error = Aromancer::Storage.get_last_error
-    return if last_error.nil?
+    last_error = Aromancer::Storage.get_last_error&.symbolize_keys
 
-    last_error = last_error.symbolize_keys
+    return if last_error.nil?
     message = last_error[:body]
     begin
       message = JSON.parse(message).symbolize_keys
       message = message[:error_message] if message.keys.include?(:error_message)
+    rescue TypeError => e
+      message = last_error[:body]
     rescue JSON::ParserError => e
       message = last_error[:body]
     end

data/lib/reiquire.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 =begin
 
   reiquire.rb

data/listen.rb

@@ -1,10 +1,6 @@
 require :listen.to_s
 
 listener = Listen.to(*[:lib.to_s, :bin.to_s, :spec.to_s, :locale.to_s], only: /[\.rb\.yml]/) {|modified, added, removed|
-  # puts modified
-  # puts added
-  # puts removed 
-  # system("exec rake make")
   system("exec rake install")
 }
 listener.start

data/locale/en.yml

@@ -13,6 +13,7 @@ en:
     update_confirm: "confirm update [%{new_value}] (enter y): "
     signed_in_as: "authenticated as %{as}"
     last_error: "error (%{status}). %{error}"
+    waiting: "waiting..."
     back: "back"
     exit: "exit"
   routes:
@@ -68,7 +69,7 @@ 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..."
+      returning_to_: "returning to %{route}..."
       your_alchemy: "alchemy"
     legends:
       help: ""

data/pre-commit.git.template

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+echo "pre-commit hook"
+echo "rake build:checksum && git add checksums/"
+rake build:checksum && git add checksums/

data/tasks/make.rake

@@ -1,4 +1,4 @@
-desc "bundle graph && rake install && rspec --backtrace"
+desc "rake install"
 task :make do
-  exec "bundle graph && rake install && rspec --backtrace"
+  exec "rake install"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aromancer
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - i2097i
@@ -227,6 +227,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".DS_Store"
 - ".gitignore"
 - ".rspec"
 - ".ruby-version"
@@ -235,7 +236,6 @@ files:
 - Gemfile
 - Gemfile.lock
 - LICENSE
-- LICENSE.txt
 - README.md
 - Rakefile
 - aromancer.gemspec
@@ -247,12 +247,14 @@ files:
 - checksums/aromancer-0.0.5.gem.sha512
 - checksums/aromancer-0.0.6.gem.sha512
 - checksums/aromancer-0.0.7.gem.sha512
-- gem_graph.png
+- checksums/aromancer-0.0.8.gem.sha512
 - lib/aromancer.rb
 - lib/aromancer/.DS_Store
 - lib/aromancer/api.rb
+- lib/aromancer/cli.rb
 - lib/aromancer/prompt.rb
 - lib/aromancer/routes.rb
+- lib/aromancer/serve.rb
 - lib/aromancer/server.rb
 - lib/aromancer/storage.rb
 - lib/aromancer/version.rb
@@ -260,6 +262,7 @@ files:
 - lib/reiquire.rb
 - listen.rb
 - locale/en.yml
+- pre-commit.git.template
 - sig/aromancer.rbs
 - tasks/console.rake
 - tasks/make.rake

data/LICENSE.txt

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2026 i2097i
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.