aromancer 0.0.7 → 0.0.9

data/lib/aromancer/storage.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 =begin
 
   storage.rb
@@ -12,28 +14,127 @@ module Aromancer
   class Storage
     include Singleton
 
-    DEFAULT_SERVER = "http://127.0.0.1"
+    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_PREFERENCES = {
+      preference_debug: false,
+      preference_force_ssl: false,
+      preference_hide_sentences: true,
+      preference_hide_stream: true,
+    }
 
-    attr_accessor :storage_open, :cache
+    DEFAULT_SERVER_URL = :"http://127.0.0.1:3000".to_s
+
+    attr_accessor :storage_open, :cache, :clear_flag, :parser_error
 
     def initialize
+      reload!
+    end
+
+    def ensure_default_preferences_exist
+      DEFAULT_PREFERENCES.each{|d_key, d_value|
+        current_value = get_key(d_key)
+        if current_value.nil? || ![TrueClass, FalseClass].include?(current_value.class)
+          set_key(d_key.to_s, d_value)
+        end
+      }
+    end
+
+    def reload!
+      @storage_open = false
+      @clear_flag = false
+      @parser_error = nil
       clear_cache!
-      FileUtils.mkdir_p(Aromancer.home_directory)
+      Aromancer.configure_home
     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
-      filepath = File.join(Aromancer.home_directory, "storage.json")
+      filepath = File.join(Aromancer.home_directory, "v#{Aromancer::VERSION}.json")
 
       # create storage file if not present
       unless File.exist?(filepath)
         File.open(filepath, "w+") do |f|
-          f.write({version: Aromancer::VERSION, created: Time.now}.to_json)
+          f.write({created_at: Time.now}.to_json)
         end
+      else
+
       end
 
       filepath
@@ -50,33 +151,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 +185,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 +193,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 +201,8 @@ module Aromancer
     end
 
     def self.set_arena(arena_hash)
-      Aromancer::Storage.instance.set_key(:arena, arena_hash)
+      instance.set_key(:arena, arena_hash)
+      Aromancer::UnixDom.render_arena
     end
 
     def self.get_arena
@@ -108,7 +210,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,33 +218,26 @@ 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)
+        set_server_url(DEFAULT_SERVER_URL)
       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?}
+      set_server_url(DEFAULT_SERVER_URL) 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
@@ -159,12 +254,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
@@ -176,78 +271,104 @@ module Aromancer
     end
 
     def get_key(key)
-      key = key.to_s
+      Aromancer::Cli.instance.storage_mutex.synchronize do
+        key = key.to_s
 
-      # ensure default for key exists
-      @cache[key] = {value: nil, persisted: false} unless @cache.keys.include?(key)
+        # 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]
+
+        # open storage
+        @storage_open = true
+        storage_contents = {}
+        begin
+          @parser_error = nil
+          # read storage
+          storage_contents = JSON.parse(File.read(Aromancer::Storage.storage_filepath, encoding: "UTF-8"))
+        rescue StandardError => e
+          @storage_open = false
+          if @parser_error.nil?
+            @parser_error = e
+            return get_key(key)
+          else
+            raise @parser_error
+          end
+        end
 
-      # return cache value if storage open or the cache value is persisted
-      return @cache[key][:value] if @storage_open || @cache[key][:persisted]
+        # 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
 
-      # open storage
-      @storage_open = true
-      storage_contents = {}
-      begin
-        # read storage
-        storage_contents = JSON.parse(File.read(Aromancer::Storage.storage_filepath))
-      rescue StandardError => e
+        value = @cache[key][:value]
         @storage_open = false
-        FileUtils.rm(Aromancer::Storage.storage_filepath)
-        return
+        clear_cache! if @clear_flag
+        return value
       end
+    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
+    def set_key(key, value)
+      Aromancer::Cli.instance.storage_mutex.synchronize do
+        key = key.to_s
+
+        # ensure default for key exists
+        @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
-      end
 
-      @storage_open = false
-      @cache[key][:value]
-    end
+        if @storage_open && (@cache[:preference_debug.to_s] || {value: DEFAULT_PREFERENCES[:preference_debug]})[:value]
+          Aromancer::Prompt.say("#{__method__} > @cache[#{key}]=#{@cache[key]}")
+        end
+        # return if storage open
+        # non-persisted cache values update next cycle
+        return if @storage_open
+
+        # open storage
+        @storage_open = true
+        storage_contents = {}
+        begin
+          @parser_error = nil
+          # read storage
+          storage_contents = JSON.parse(File.read(Aromancer::Storage.storage_filepath, encoding: "UTF-8"))
+        rescue StandardError => e
+          @storage_open = false
+          if @parser_error.nil?
+            @parser_error = e
+            return get_key(key)
+          else
+            raise @parser_error
+          end
+        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)
-
-      # 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
+        }
 
-      # 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
 
-      # write storage
-      File.open(Aromancer::Storage.storage_filepath, "w+") do |f|
-        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
+        # close storage
+        @storage_open = false
+        clear_cache! if @clear_flag
+      end
     end
   end
 end

data/lib/aromancer/unix_dom.rb

@@ -0,0 +1,13 @@
+module Aromancer
+  class UnixDom
+
+    def self.render_arena
+      arena = Aromancer::Storage.get_arena
+      return unless arena.present?
+
+      # Aromancer.arena_directory
+      # todo:
+    end
+
+  end
+end

data/lib/aromancer/version.rb

@@ -11,5 +11,5 @@
 =end
 
 module Aromancer
-  VERSION = "0.0.7"
+  VERSION = "0.0.9"
 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::Cli.instance.should_clear_cache = true
+              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