aromancer 0.0.4 → 0.0.5

data/lib/aromancer/routes.rb

@@ -13,43 +13,159 @@
 module Aromancer
   class Routes
 
+    def self.resume
+      unless Thread.main[:route].nil?
+        if (Thread.main[:route_params] || []).any?
+          self.send(Thread.main[:route], *Thread.main[:route_params])
+        else
+          self.send(Thread.main[:route])
+        end
+        Thread.main[:route_params] = nil
+        Thread.main[:route] = nil
+        return
+      end
+
+      legend_menu if !active_legend.nil? &&
+        (Aromancer::Storage.get_player && Aromancer::Storage.get_player&.symbolize_keys[:active_legend_id])
+      authentication
+    end
+
     def self.cls
-      TTY::Cursor.clear_screen
-      TTY::Cursor.clear_screen_up
+      puts TTY::Screen.width
+      print TTY::Cursor.move(0, 0)
+      print TTY::Cursor.clear_screen
+      print TTY::Cursor.clear_screen_up
+    end
+
+    def self.active_legend
+      Aromancer::Api.get_legends
+
+      (
+        Aromancer::Storage.get_legends&.select{|l| l["id"] == Aromancer::Storage.get_player["active_legend_id"]} || []
+      ).first
+    end
+
+    def self.arena_data
+      arena = Aromancer::Storage.get_arena
+      if arena.nil?
+        Aromancer.print_last_error("routes.legend.arena_failed")
+        Aromancer::Api.set_active_legend_id(nil)
+        main_menu
+      else
+        arena
+      end
     end
 
-    def self.authentication(require_key_press = false)
+    def self.authentication
+      if Aromancer::Storage.get_player
+        Aromancer::Storage.set_signed_out_flag(false)
+        return main_menu
+      end
       Aromancer::Prompt.say(I18n.t("shared.navigate", route: :authentication))
-      Aromancer::Prompt.p.ask(I18n.t("shared.key_press")) if require_key_press
 
       choices = [
         {name: I18n.t("routes.authentication.sign_in"), value: :in},
         {name: I18n.t("routes.authentication.sign_up"), value: :up},
+        {name: I18n.t("routes.main_menu.configure"), value: :configure},
         {name: I18n.t("shared.exit"), value: :exit}
       ]
-      text = ""#Aromancer.get_font(I18n.t("routes.authentication.title")).join("\n") +
-        "\n#{I18n.t("routes.authentication.subtitle")}"
-      case Aromancer::Prompt.p.select(text, choices, show_help: :always, cycle: true, per_page: 11)
-      when :in
-        Aromancer::Api.sign_in
-      when :up
-        Aromancer::Api.sign_up
-      else
-        exit
-      end
 
-      if Aromancer::Storage.get_player
-        Aromancer::Storage.set_signed_out_flag(false)
-        main_menu
-      else
-        Aromancer.print_last_error("routes.authentication.failed")
-        authentication(true)
-      end
+      Thread.main[:input_controls] = {
+        choices: choices,
+        runners: [
+          {value: :in, proc: Proc.new{
+            Aromancer::Api.sign_in
+            authentication
+          }},
+          {value: :up, proc: Proc.new{
+            Aromancer::Api.sign_up
+            authentication
+          }},
+          {value: :configure, proc: Proc.new{
+            configure
+          }}
+        ]
+      }
+      Thread.main[:route] = __method__.to_s
     end
 
-    def self.active_legend
-      Aromancer::Api.get_legends
-      Aromancer::Storage.get_legends.select{|l| l["id"] == Aromancer::Storage.get_player["active_legend_id"]}.first
+    def self.configure
+      cls
+
+      Aromancer::Prompt.say(I18n.t("routes.configure.title", name: Aromancer.to_s.downcase))
+      [
+        Aromancer::Storage.get_server_url,
+        Aromancer::Storage.get_websocket_url
+      ].each{|l|
+        Aromancer::Prompt.say(l)
+      }
+
+      choices = [
+        {name: I18n.t("shared.back"), value: :back},
+        {name: I18n.t("routes.configure.server_host", stored: Aromancer::Storage.instance.get_key(:server_url_host)), value: :host},
+        {name: I18n.t("routes.configure.server_port", stored: Aromancer::Storage.instance.get_key(:server_url_port)), value: :port},
+        {name: I18n.t("routes.configure.force_ssl", stored: Aromancer::Storage.get_preference(:force_ssl, default: true)), value: :force_ssl}
+      ]
+
+      server_url_update = Proc.new{|property|
+
+        updated = nil
+        storage_key = "server_url_#{property}"
+        previous = Aromancer::Storage.instance.get_key(storage_key)
+        while updated.nil? || updated.blank? || updated != Aromancer::Storage.instance.get_key(storage_key)
+          # get user input
+          updated = Aromancer::Prompt.p.ask(I18n.t("routes.configure.new_#{property}"))
+
+          if property.to_sym == :port
+            updated = updated.to_i
+            next unless updated > 0
+          end
+
+          # set new host value in storage
+          Aromancer::Storage.instance.set_key(storage_key, updated)
+
+          confirmed = false
+          begin
+            confirmed = Aromancer::Prompt.p.ask(I18n.t("shared.update_confirm", new_value: Aromancer::Storage.get_server_url))
+          rescue StandardError => e
+            Aromancer::Prompt.say(e)
+          end
+
+          unless :y.to_s == confirmed
+            # reset to old value
+            Aromancer::Prompt.say(I18n.t("shared.update_cancel"))
+            Aromancer::Storage.instance.set_key(storage_key, previous)
+          end
+
+          Aromancer::Storage.instance.clear_cache!
+        end
+        Aromancer::Prompt.say(I18n.t("shared.server_url", url: Aromancer::Storage.get_server_url))
+      }
+
+      Thread.main[:input_controls] = {
+        choices: choices,
+        runners: [
+          {value: :back, proc: Proc.new{ main_menu }},
+          {value: :host, proc: Proc.new{
+            server_url_update.call(:host)
+            configure
+          }},
+          {value: :port, proc: Proc.new{
+            server_url_update.call(:port)
+            configure
+          }},
+          {value: :force_ssl, proc: Proc.new{
+            Aromancer::Storage.toggle_force_ssl
+            Aromancer::Prompt.say(I18n.t("shared.server_url", url: Aromancer::Storage.get_server_url))
+            Aromancer::Prompt.say(
+              I18n.t("routes.configure.force_ssl_toggle", value: Aromancer::Storage.get_preference(:force_ssl))
+            )
+            sleep(2)
+            configure
+          }},
+        ]
+      }
+      Thread.main[:route] = __method__.to_s
     end
 
     def self.main_menu
@@ -66,36 +182,52 @@ module Aromancer
       return legend_menu if (!player.nil? && !player[:active_legend_id].nil?) ||
         (!al.nil? && al["status"] == "started")
 
+      return authentication if player.nil?
+
       choices = [
         {name: I18n.t("routes.main_menu.new_game"), value: :new},
         {name: I18n.t("routes.main_menu.load_game"), value: :load},
+        {name: I18n.t("routes.main_menu.configure"), value: :configure},
         {name: I18n.t("routes.main_menu.sign_out"), value: :out},
         {name: I18n.t("shared.exit"), value: :exit}
       ]
-      text = ""#Aromancer.get_font(I18n.t("routes.main_menu.title")).join("\n") +
-        "\n#{I18n.t("routes.main_menu.subtitle")}"
-      case Aromancer::Prompt.p.select(text, choices, show_help: :always, cycle: true, per_page: 11)
-      when :new
-        new_game
-      when :load
-        legends
-      when :out
-        case Aromancer::Prompt.p.select(I18n.t("shared.confirm"), [:no, :yes], cycle: true, per_page: 11)
-        when :no
-          main_menu
-        when :yes
-          Aromancer::Api.sign_out
-          authentication
-        end
-      else
-        exit
-      end
+
+      Thread.main[:input_controls] = {
+        choices: choices,
+        runners: [
+          {value: :new, proc: Proc.new{
+            # this will run on the main thread
+            params = Aromancer::Api::DEFAULT_LEGEND_PARAMS.dup
+
+            player_count = nil
+            while player_count.nil? || ![1, 2].include?(player_count&.to_i)
+              player_count = Aromancer::Prompt.p.ask(I18n.t("routes.main_menu.player_count"))
+            end
+            params[:player_count] = player_count
+            new_game(params)
+          }},
+          {value: :load, proc: Proc.new{ Aromancer::Routes::legends }},
+          {value: :configure, proc: Proc.new{
+            configure
+          }},
+          {value: :out, proc: Proc.new{
+            case Aromancer::Prompt.p.select(I18n.t("shared.confirm"), [:no, :yes], cycle: true, per_page: 11)
+            when :no
+              main_menu
+            when :yes
+              Aromancer::Api.sign_out
+              authentication
+            end
+          }}
+        ]
+      }
+      Thread.main[:route] = __method__.to_s
     end
 
-    def self.new_game
+    def self.new_game(params)
       cls
       Aromancer::Prompt.say(I18n.t("shared.navigate", route: :new_game))
-      params = Aromancer::Api::DEFAULT_LEGEND_PARAMS.dup
+
       data = [
         [I18n.t("routes.new_game.player_count"), params[:player_count]],
         [I18n.t("routes.new_game.story_count"), params[:story_count]],
@@ -104,13 +236,32 @@ module Aromancer
       table = TTY::Table.new(data)
       Aromancer::Prompt.say(table.render(:unicode))
 
-      # TODO: edit params here
-
       Aromancer::Prompt.say(I18n.t("routes.new_game.starting"))
-      Aromancer::Api.create_legend(params)
-      Aromancer::Prompt.p.ask(I18n.t("shared.key_press"))
 
-      main_menu
+      choices = [
+        {name: :continue, value: :continue},
+        {name: :cancel, value: :cancel}
+      ]
+      Thread.main[:input_controls] = {
+        choices: choices,
+        runners: [
+          {value: :continue, proc: Proc.new{
+            Aromancer::Api.create_legend(params)
+            timeout = 1
+            while active_legend.nil? || timeout >= 11
+              Aromancer::Prompt.say(I18n.t("routes.new_game.starting"))
+              sleep(2)
+              timeout += 1
+            end
+
+            legend_menu
+          }},
+          {value: :cancel, proc: Proc.new{
+            Aromancer::Prompt.say(I18n.t("routes.new_game.cancelled"))
+            main_menu
+          }}
+        ]
+      }
     end
 
     def self.legends
@@ -118,26 +269,36 @@ module Aromancer
       legend_array = Aromancer::Storage.get_legends
       unless legend_array.any?
         Aromancer::Prompt.say(I18n.t("shared.empty"))
-        Aromancer::Prompt.p.ask(I18n.t("shared.key_press"))
+        # Aromancer::Prompt.p.ask(I18n.t("shared.key_press"))
         main_menu
       end
-      choices = [{name: :back, value: :back}] + legend_array.map{|l|
+      choices = [{name: I18n.t("shared.back"), value: :back}] + legend_array.map{|l|
         {
           name: "#{I18n.t("routes.legend.title")}_#{l["id"]} (#{l["status"]}) #{DateTime.parse(l["created_at"])&.strftime(Aromancer::Api::DATE_FORMAT)}",
           value: l["id"]
         }
       }
-      selected_legend_id = Aromancer::Prompt.p.select("", choices, help: I18n.t("routes.legends.help"), show_help: :always, cycle: true, per_page: 11)
-
-      if selected_legend_id == :back
-        return main_menu
-      end
 
-      Aromancer::Api.set_active_legend_id(selected_legend_id)
-      legend_menu
+      Thread.main[:input_controls] = {
+        choices: choices,
+        runners: [
+          {value: :back, proc: Proc.new{ main_menu }},
+        ] + legend_array.map{|l|
+          {
+            value: l["id"],
+            proc: Proc.new{
+              Aromancer::Api.set_active_legend_id(l["id"])
+              legend_menu
+            }
+          }
+        }
+      }
+      Thread.main[:route] = __method__.to_s
     end
 
     def self.stream
+      # todo: this needs to be set as a view mode
+      # currently it gets overwritten
       Aromancer::Api.load_stream
       stream = Aromancer::Storage.get_stream
       Aromancer::Prompt.say(I18n.t("routes.stream.title"))
@@ -150,22 +311,41 @@ module Aromancer
         Aromancer::Prompt.say("\n")
         Aromancer::Prompt.say([e["updated_at"], e["description"]].join("\n"))
       }
-      Aromancer::Prompt.p.ask(I18n.t("shared.key_press"))
-      legend_menu
+
+      Thread.main[:input_controls] = {
+        choices: [{name: I18n.t("shared.key_press"), value: nil}],
+        runners: [{value: nil, proc: Proc.new{ legend_menu }}]
+      }
+      Thread.main[:route] = __method__.to_s
     end
 
     def self.legend_menu
       cls
-      # Aromancer::Prompt.say(I18n.t("shared.navigate", route: :legend_menu))
       legend
 
       legend_array = Aromancer::Storage.get_legends
       al = active_legend
-      if !al.nil? && al["status"] == "complete"
-        Aromancer::Api.set_active_legend_id(nil)
-        Aromancer::Prompt.say(I18n.t("routes.legend.legend_complete"))
-        Aromancer::Prompt.p.ask(I18n.t("shared.key_press"))
-        return legends
+      if !al.nil?
+        if al["status"] == "complete"
+          Aromancer::Api.set_active_legend_id(nil)
+          Aromancer::Prompt.say(I18n.t("routes.legend.legend_complete"))
+          # Aromancer::Prompt.p.ask(I18n.t("shared.key_press"))
+          return legends
+        elsif al["status"] == "created"
+          choices = [{name: :reload, value: :reload}, {name: I18n.t("shared.back"), value: :back}]
+          Thread.main[:input_controls] = {
+            choices: choices,
+            runners: [
+              {value: :reload, proc: Proc.new{ legend_menu }},
+              {value: :back, proc: Proc.new{
+                Aromancer::Api.set_active_legend_id(nil)
+                main_menu
+              }}
+            ]
+          }
+          Thread.main[:route] = __method__.to_s
+          return
+        end
       end
 
       hs = Aromancer::Storage.get_preference(:hide_sentences, default: true)
@@ -178,30 +358,44 @@ module Aromancer
         {name: I18n.t("routes.stream.title"), value: :stream},
         {name: I18n.t("routes.main_menu.title"), value: :main_menu}
       ]
-      text = ""#Aromancer.get_font(I18n.t("routes.legend_menu.title")).join("\n") +
-        "\n#{I18n.t("routes.legend_menu.subtitle")}"
-      case Aromancer::Prompt.p.select(text, choices, help: I18n.t("routes.legend_menu.help"), show_help: :always, cycle: true, per_page: 11)
-      when :words
-        words
-      when :spoken_words
-        spoken_words
-      when :unsigned_sentences
-        unsigned_sentences
-      when hs_value
-        Aromancer::Storage.set_preference(:hide_sentences, !hs)
-        legend_menu
-      when :stream
-        stream
-      when :main_menu
-        Aromancer::Api.set_active_legend_id(nil)
-        main_menu
-      end
+
+      Thread.main[:input_controls] = {
+        choices: choices,
+        runners: [
+          {value: :words, proc: Proc.new{ words }},
+          {value: :spoken_words, proc: Proc.new{ spoken_words }},
+          {value: :unsigned_sentences, proc: Proc.new{ unsigned_sentences }},
+          {value: hs_value, proc: Proc.new{
+            Aromancer::Storage.set_preference(:hide_sentences, !hs)
+            legend_menu
+          }},
+          {value: :stream, proc: Proc.new{ stream }},
+          {value: :main_menu, proc: Proc.new{
+            Aromancer::Api.set_active_legend_id(nil)
+            main_menu
+          }},
+        ]
+      }
+      Thread.main[:route] = __method__.to_s
     end
 
     def self.legend
       Aromancer::Prompt.say(I18n.t("shared.navigate", route: :legend))
       Aromancer::Api.load_arena
       arena = arena_data
+      al = active_legend
+      if !al.nil? && al["status"] == "created"
+        Aromancer::Prompt.say(arena["title"])
+        Aromancer::Prompt.say(I18n.t("routes.legend.players"))
+        Aromancer::Prompt.say(arena["players"].map{|p| p["alias"]})
+        # Aromancer::Prompt.p.ask(I18n.t("shared.key_press"))
+        return
+      elsif !al.nil? && al["status"] == "complete"
+        Aromancer::Api.set_active_legend_id(nil)
+        main_menu
+      end
+
+      return if arena.nil? || arena["turn_player"].nil?
 
       # puts arena.to_json
       turn_player = arena["turn_player"]
@@ -275,14 +469,67 @@ module Aromancer
       legend
 
       arena = arena_data
-      choices = [{name: :back, value: :back}] + arena["player"]["words"].map{|w| {name: w["value_display"], value: w["id"]}}
-      selected_word_id = Aromancer::Prompt.p.select("", choices, show_help: :always, cycle: true, per_page: 11)
+      choices = [{name: I18n.t("shared.back"), value: :back}] + arena["player"]["words"].map{|w| {name: w["value_display"], value: w["id"]}}
+
+      Thread.main[:input_controls] = {
+        choices: choices,
+        runners: [
+          {value: :back, proc: Proc.new{ legend_menu }}
+        ] + arena["player"]["words"].map{|w|
+            {value: w["id"], proc: Proc.new{
+              word(w["id"])
+            }}
+        }
+      }
+      Thread.main[:route] = __method__.to_s
+    end
 
-      if selected_word_id == :back
-        return legend_menu
-      end
+    def self.spoken_words
+      cls
+      legend
+
+      arena = arena_data
+      choices = [{name: I18n.t("shared.back"), value: :back}] + arena["scroll_words"].map{|w| {name: w["value_display"], value: w["id"]}}
+
+      Thread.main[:input_controls] = {
+        choices: choices,
+        runners: [
+          {value: :back, proc: Proc.new{ legend_menu }}
+        ] + arena["scroll_words"].map{|w|
+            {value: w["id"], proc: Proc.new{
+               word(w["id"])
+            }}
+        }
+      }
+      Thread.main[:route] = __method__.to_s
+    end
+
+    def self.unsigned_sentences
+      cls
+      legend
 
-      word(selected_word_id)
+      arena = arena_data
+      choices = [{name: I18n.t("shared.back"), value: :back}] + arena["sentences"].map{|s| {name: "id: #{s["id"]}, value: #{s["value"]}", value: s["id"]}}
+
+      Thread.main[:input_controls] = {
+        choices: choices,
+        runners: [
+          {value: :back, proc: Proc.new{ legend_menu }}
+        ] + arena["sentences"].map{|s|
+            ss_words = s["words"]
+            wid = ss_words.first["id"]
+            {value: s["id"], proc: Proc.new{
+
+              # todo: probably do not need this check
+              # if ss_words.nil? || ss_words.empty?
+                # legend_menu
+              # else
+                word(wid)
+              # end
+            }}
+        }
+      }
+      Thread.main[:route] = __method__.to_s
     end
 
     def self.word(selected_word_id)
@@ -292,7 +539,7 @@ module Aromancer
       possibilities = Aromancer::Api.load_word_possibilities(selected_word_id)
 
       # todo: hide/show this
-      puts JSON.pretty_generate possibilities
+      # puts JSON.pretty_generate possibilities
 
       options = possibilities["options"]
       selected_word = possibilities["word"]
@@ -322,93 +569,52 @@ module Aromancer
 
         "#{sw["value_display"]} #{a} #{o_value_display} #{calc}"
       }
-
+      place_title = I18n.t("routes.legend.place_on_scroll", word: selected_word["value_display"])
       choices = [
-        {name: :back, value: :back}
+        {name: I18n.t("shared.back"), value: :back}
       ]
       if for_type == :player_word
         # show place on scroll option if selected word is from player's words
-        choices << {name: I18n.t("routes.legend.place_on_scroll", word: selected_word["value_display"]), value: :player_word}
+        choices << {name: place_title, value: :player_word}
       end
       choices += options.map{|o| {name: option_display.call(o, selected_word), value: o}}
-      selected_option = Aromancer::Prompt.p.select(
-        I18n.t("routes.legend.options_for_word", word: selected_word["value_display"]),
-        choices,
-        show_help: :always, cycle: true, per_page: 11
-      )
-
-      if selected_option == :back
-        return case for_type
-        when :player_word
-          words
-        when :scroll_word
-          spoken_words
-        when :scroll_sentence
-          unsigned_sentences
-        end
-      elsif selected_option == :player_word
-        wytyd = I18n.t("routes.legend.place_on_scroll", word: selected_word["value_display"])
-        Aromancer::Prompt.say(wytyd)
-        Aromancer::Api.create_turn({
-          wytyd: wytyd,
-          word_id: selected_word["id"]
-        })
-        legend_menu
-      else
-        if selected_option["http_verb"] == "post"
-          Aromancer::Api.create_turn(JSON.parse(selected_option["payload"]))
-        else
-          Aromancer::Api.update_turn(JSON.parse(selected_option["payload"]))
-        end
 
-        legend_menu
-      end
-    end
-
-    def self.spoken_words
-      cls
-      legend
-
-      arena = arena_data
-      choices = [{name: :back, value: :back}] + arena["scroll_words"].map{|w| {name: w["value_display"], value: w["id"]}}
-      selected_word_id = Aromancer::Prompt.p.select(I18n.t("routes.legend.spoken_words"), choices, show_help: :always, cycle: true, per_page: 11)
-
-      if selected_word_id == :back
-        return legend_menu
-      end
-
-      word(selected_word_id)
-    end
-
-    def self.unsigned_sentences
-      cls
-      legend
-
-      arena = arena_data
-      choices = [{name: :back, value: :back}] + arena["sentences"].map{|s| {name: "id: #{s["id"]}, value: #{s["value"]}", value: s}}
-      selected_sentence = Aromancer::Prompt.p.select(I18n.t("routes.legend.unsigned_sentences"), choices, show_help: :always, cycle: true, per_page: 11)
-
-      if selected_sentence == :back
-        return legend_menu
-      end
-
-      return legend_menu if selected_sentence.nil?
-      ss_words = selected_sentence["words"]
-      return legend_menu if  ss_words.nil? || ss_words.empty?
+      Thread.main[:input_controls] = {
+        choices: choices,
+        runners: [
+          {value: :back, proc: Proc.new{
+            case for_type
+            when :player_word
+              words
+            when :scroll_word
+              spoken_words
+            when :scroll_sentence
+              unsigned_sentences
+            end
+          }},
+          {value: :player_word, proc: Proc.new{
+            wytyd = I18n.t("routes.legend.place_on_scroll", word: selected_word["value_display"])
+            Aromancer::Prompt.say(wytyd)
+            Aromancer::Api.create_turn({
+              wytyd: wytyd,
+              word_id: selected_word["id"]
+            })
+            legend_menu
+          }},
+          {value: nil, proc: Proc.new{|o|
+            if o["http_verb"] == "post"
+              Aromancer::Api.create_turn(JSON.parse(o["payload"]))
+            else
+              Aromancer::Api.update_turn(JSON.parse(o["payload"]))
+            end
+
+            legend_menu
+          }}
+        ]
+      }
 
-      word(selected_sentence["words"].first["id"])
+      Thread.main[:route] = __method__.to_s
+      Thread.main[:route_params] = [selected_word_id]
     end
-
-    def self.arena_data
-      arena = Aromancer::Storage.get_arena
-      if arena.nil?
-        Aromancer.print_last_error("routes.legend.arena_failed")
-        Aromancer::Api.set_active_legend_id(nil)
-        main_menu
-      else
-        arena
-      end
-    end
-
   end
 end