textflight-client 1.0.1

data/lib/textflight-client/models/scan.rb

@@ -0,0 +1,222 @@
+
+module TFClient
+  module Models
+
+    class Scan < Response
+      LINE_IDENTIFIERS = [
+        "Owner",
+        "Operators",
+        "Outfit space",
+        "Shield charge",
+        "Outfits",
+        "Cargo"
+      ]
+
+      attr_reader :id, :name, :owner, :outfit_space, :shield_charge
+      attr_reader :outfits, :cargo
+
+      def initialize(lines:)
+        super(lines: lines)
+
+        ship_line = lines[0]
+        values_hash = ResponseParser.hash_from_line_values(line: ship_line)
+        @id = values_hash[:id].to_i
+        @name = values_hash[:name]
+
+        LINE_IDENTIFIERS.each do |line_id|
+
+          # Not sure what value this adds
+          next if line_id == "Operators"
+
+          var_name = ResponseParser.snake_case_sym_from_string(string: line_id)
+          class_name = ResponseParser.camel_case_from_string(string: line_id)
+          clazz = ResponseParser.model_class_from_string(string: class_name)
+
+          if clazz.nil?
+            raise "could not find class name: #{class_name} derived from #{line_id}"
+          end
+
+          line, _ = ResponseParser.line_and_index_for_beginning_with(lines: @lines,
+                                                                     string: line_id)
+
+          if ["Owner", "Outfit space", "Shield charge"].include?(line_id)
+            var = clazz.new(line: line)
+          elsif ["Outfits", "Cargo"].include?(line_id)
+            var = clazz.new(lines: @lines)
+            if var.is_a?(TFClient::Models::Outfits)
+              var.max_slots = @outfit_space.value
+            end
+          else
+            raise "Cannot find class initializer for: #{line_id}"
+          end
+
+          instance_variable_set("@#{var_name}", var)
+        end
+      end
+
+      def response
+        # TODO this is interesting only when you scan _other_ structures
+        # table = TTY::Table.new(header: [
+        #   {value: @owner.translation, alignment: :center},
+        #   {value: @outfit_space.translation, alignment: :center},
+        #   {value: @shield_charge.translation, alignment: :center}
+        # ])
+        #
+        # table << [@owner.username,
+        #           @outfit_space.value,
+        #           @shield_charge.value]
+        #
+        # puts table.render(:ascii, padding: [0,1,0,1],
+        #                   width: Models::TABLE_WIDTH, resize: true) do |renderer|
+        #   renderer.alignments= [:center, :center, :center]
+        # end
+
+        puts @outfits.to_s
+        puts @cargo.to_s
+      end
+    end
+
+    class Owner < Model
+      attr_reader :username
+
+      def initialize(line:)
+        super(line: line)
+        @username = @values_hash[:username]
+      end
+
+      def to_s
+        "#{@translation}: #{@username}"
+      end
+    end
+
+    class OutfitSpace < Model
+      attr_reader :value
+
+      def initialize(line:)
+        super(line: line)
+        @value = @values_hash[:space].to_i
+      end
+
+      def to_s
+        "#{@translation}: #{@value}"
+      end
+    end
+
+    class ShieldCharge < Model
+      attr_reader :value
+
+      def initialize(line:)
+        super(line: line)
+        @value = @values_hash[:charge].to_f
+      end
+
+      def to_s
+        "#{@translation}: #{@value}"
+      end
+    end
+
+    class Outfits < ModelWithItems
+
+      attr_accessor :max_slots
+
+      def initialize(lines:)
+        line, index = ResponseParser.line_and_index_for_beginning_with(lines: lines,
+                                                                       string: "Outfits")
+        super(line: line)
+
+        items = ResponseParser.collect_list_items(lines: lines, start_index: index + 1)
+        @items = items.map do |item|
+          line = item.strip
+
+          hash = ResponseParser.hash_from_line_values(line: line)
+
+          index = hash[:index].to_i
+          name = hash[:name]
+          mark = hash[:mark].to_i
+          setting = hash[:setting].to_i
+          { index: index, name: name, mark: mark, setting: setting}
+        end
+        @max_slots = 0
+      end
+
+      def to_s
+        table = TTY::Table.new(header: [
+          "#{@translation}: #{slots_used}/#{@max_slots} slots",
+          {value: "name", alignment: :center},
+          {value: "setting", alignment: :center},
+          {value: "index", alignment: :center}
+        ])
+
+        @items.each do |item|
+          table << [
+            "[#{item[:index]}]",
+            "#{item[:name]} (#{item[:mark].to_roman})",
+            item[:setting],
+            "[#{item[:index]}]"
+          ]
+        end
+
+        table.render(:ascii, Models::TABLE_OPTIONS) do |renderer|
+          renderer.alignments= [:right, :right, :center, :center]
+        end
+      end
+
+      def slots_used
+        @items.map { |hash| hash[:mark] }.sum
+      end
+    end
+
+    class Cargo < ModelWithItems
+
+      def initialize(lines:)
+        line, index = ResponseParser.line_and_index_for_beginning_with(lines: lines,
+                                                                       string: "Cargo")
+        super(line: line)
+
+        items = ResponseParser.collect_list_items(lines: lines, start_index: index + 1)
+        @items = items.map do |item|
+          line = item.strip
+
+          hash = ResponseParser.hash_from_line_values(line: line)
+
+          index = hash[:index].to_i
+          name = hash[:name]
+          count = hash[:count].to_i
+          # TODO: this must be the mark?
+          mark = hash[:extra].to_i
+          { index: index, name: name, count: count, mark: mark}
+        end
+      end
+
+      def to_s
+        table = TTY::Table.new(header: [
+          "Weight: #{weight}",
+          {value: "cargo", alignment: :center},
+          {value: "amount", alignment: :center},
+          {value: "index", alignment: :center}
+        ])
+
+        @items.each do |item|
+          name = item[:name]
+          mark = item[:mark].to_i
+          if mark && (mark != 0)
+            name = "#{name} (#{mark.to_roman})"
+          end
+          table << ["[#{item[:index]}]",
+                    name,
+                    item[:count],
+                    "[#{item[:index]}]"]
+        end
+
+        table.render(:ascii, Models::TABLE_OPTIONS) do |renderer|
+          renderer.alignments= [:right, :right, :center, :center]
+        end
+      end
+
+      # TODO: only some items in the inventory contribute to weight
+      def weight
+        @items.map { |hash| hash[:count] }.sum
+      end
+    end
+  end
+end

data/lib/textflight-client/models/status.rb

@@ -0,0 +1,191 @@
+
+module TFClient
+  module Models
+
+    class Status < Response
+
+      # returns 2 values
+      def self.status_from_lines(lines:, start_with:)
+        stripped = lines.map { |line| line.strip }
+        prefix = start_with.strip
+        line, _ = ResponseParser.line_and_index_for_beginning_with(lines: stripped,
+                                                                   string: prefix)
+        if !lines || !line.start_with?(prefix)
+          raise "expected line to be a status line for #{prefix} in #{lines}"
+        end
+
+        tokens = ResponseParser.tokenize_line(line: line)
+
+        status = tokens[0].split(": ").last
+
+        case status
+        when "Overheat in {remaining} seconds!"
+          status = "Overheating"
+        when "OVERHEATED"
+          status = "Overheated"
+        when "Ready to engage"
+          status = "Ready"
+        when "Charging ({charge}%)"
+          status = "Charging"
+        when "FAILED"
+          status = "Failed"
+        when "BROWNOUT"
+          status = "Brownout"
+        when "OVERLOADED"
+          status = "Overloaded"
+        when "Brownout in {remaining} seconds!"
+          status = "Overloaded"
+        when "Regenerating at {rate}/s ({shield}/{max})"
+          status = "Regenerating"
+        when "{progress}% ({interval} second interval)"
+          status = "Online"
+        end
+
+        translation = tokens[1]
+
+        return status, translation if tokens.size == 2
+
+        translation = ResponseParser.substitute_line_values(line: line)
+
+        return status, translation.strip
+      end
+
+      attr_reader :states
+      attr_reader :status_report
+      attr_reader :mass, :total_outfit_space, :used_outfit_space
+      attr_reader :heat, :max_heat, :heat_rate, :cooling_status
+      attr_reader :energy, :max_energy, :energy_rate, :power_status
+      attr_reader :antigravity_engine_status, :antigravity
+      attr_reader :mining_status, :mining_interval, :mining_power
+      attr_reader :engine_status, :warp_charge
+      attr_reader :shield_status, :shield_max, :shield, :shield_charge_rate
+      attr_reader :colonists, :colonists_status
+
+      def initialize(lines:)
+        super(lines: lines)
+
+        @states = {}
+
+        @status_report = Models::StatusReport.new(lines: lines)
+        @mass = @status_report.hash[:mass].to_i
+        @total_outfit_space = @status_report.hash[:total_outfit_space].to_i
+
+        outfit_space_line = lines.detect do |line|
+          line.strip.start_with?("Outfit space")
+        end
+
+        hash = ResponseParser.hash_from_line_values(line: outfit_space_line)
+        @used_outfit_space = @total_outfit_space - hash[:space].to_i
+
+        # Cooling
+        @states[:cooling], @cooling_status = Status.status_from_lines(
+          lines: lines,
+          start_with: "Cooling status")
+        @heat = @status_report.hash[:heat].to_i
+        @max_heat = @status_report.hash[:max_heat].to_i
+        @heat_rate = @status_report.hash[:heat_rate].to_f
+
+        # Energy / Power
+        @states[:power], @power_status = Status.status_from_lines(
+          lines: lines,
+          start_with: "Power status"
+        )
+
+        @energy = @status_report.hash[:energy].to_i
+        @max_energy = @status_report.hash[:max_energy].to_i
+        @energy_rate = @status_report.hash[:energy_rate].to_f
+
+        # Antigravity
+        antigravity_line = lines.detect do |line|
+          line.strip.start_with?("Antigravity engines")
+        end
+
+        if antigravity_line
+          @states[:antigravity], @antigravity_engine_status =
+            Status.status_from_lines(lines: lines, start_with: "Antigravity engines")
+          @antigravity = @status_report.hash[:antigravity].to_i
+        else
+          # Needs translation
+          @states[:antigravity] = "Offline"
+          @antigravity = "Antigravity engines: Offline"
+        end
+
+
+
+        # Mining
+        mining_progress_line = lines.detect do |line|
+          line.strip.start_with?("Mining progress")
+        end
+
+        if mining_progress_line
+          @states[:mining], @mining_status =
+            Status.status_from_lines(lines: lines,
+                                     start_with: "Mining progress")
+          hash = ResponseParser.hash_from_line_values(line: mining_progress_line)
+          @mining_interval = hash[:interval].to_f
+          @mining_power = @status_report.hash[:mining_power].to_f
+        else
+          @mining_interval = nil
+          @mining_power = nil
+          # TODO needs a translation
+          @states[:mining] = "Offline"
+          @mining_status = "Offline"
+        end
+
+        # Warp
+        warp_line = lines.detect do |line|
+          line.strip.start_with?("Warp engines")
+        end
+        if warp_line
+          @states[:warp], @engine_status =
+            Status.status_from_lines(lines: lines,
+                                     start_with: "Warp engines")
+          @warp_charge = @status_report.hash[:warp_charge].to_f
+        else
+          @states[:warp] = "Offline"
+          @warp_charge = 0.0
+        end
+
+        # Shield
+        shield_status_line = lines.detect do |line|
+          line.strip.start_with?("Shields")
+        end
+
+        if shield_status_line
+          @states[:shields], @shield_status =
+            Status.status_from_lines(lines: lines,
+                                     start_with: "Shields")
+          @shield_charge_rate = @status_report.hash[:shield_rate].to_f
+          @shield_max = @status_report.hash[:max_shield].to_f
+          @shield = @status_report.hash[:shield].to_f
+        else
+          # TODO Need translation
+          @shield_status = "Offline"
+          @states[:shields] = "Offline"
+          @shield_charge_rate = nil
+          @shield_max = @status_report.hash[:max_shield].to_f
+          @shield = 0
+        end
+
+        # Colonists
+        colonists_line = lines.detect do |line|
+          line.strip.start_with?("Colonists")
+        end
+
+        if colonists_line
+          # TODO Need translation
+          @states[:colonists] = "Crewed"
+          @colonists_status =
+            ResponseParser.substitute_line_values(line: colonists_line)
+          hash = ResponseParser.hash_from_line_values(line: colonists_line)
+          @colonists = hash[:crew].to_i
+        else
+          # TODO Need translation
+          @states[:colonists] = "Unmanned"
+          @colonists_status = "Unmanned"
+          @colonists = 0
+        end
+      end
+    end
+  end
+end

data/lib/textflight-client/models/status_report.rb

@@ -0,0 +1,26 @@
+
+module TFClient
+  module Models
+
+    STATUS_BEGIN = "STATUSREPORT BEGIN".freeze
+    STATUS_END = "STATUSREPORT END".freeze
+
+    class StatusReport
+
+      attr_reader :hash
+
+      def initialize(lines:)
+        if lines[0] != STATUS_BEGIN
+          raise "Expected lines[0] to be == #{STATUS_BEGIN}, found: #{lines[0]}"
+        end
+
+        @hash = {}
+        lines.each do |line|
+          break if line == STATUS_END
+          tokens = line.strip.split(": ")
+          @hash[tokens[0].to_sym] = tokens[1]
+        end
+      end
+    end
+  end
+end

data/lib/textflight-client/response_parser.rb

@@ -0,0 +1,200 @@
+
+module TFClient
+  class ResponseParser
+
+    FIELD_DELIMITER = "|".freeze
+    VARIABLE_REGEX = /(\{[a-z_]+\}+)/.freeze
+
+    def self.substitute_line_values(line:)
+      return line.chomp if !line[/\|/]
+      tokens = line.chomp.split("|")
+
+      translation = tokens[1]
+
+      matches = translation.scan(VARIABLE_REGEX)
+
+      return translation  if matches.empty?
+
+      values = self.hash_from_line_values(line: line.chomp)
+
+      with_substitutes = translation.chomp
+
+      matches.each do |match|
+        key = match[0].sub("{", "").sub("}", "").to_sym
+        with_substitutes.gsub!(match[0], values[key])
+      end
+
+      with_substitutes
+    end
+
+    def self.substitute_values(lines:)
+      lines.map do |line|
+        self.substitute_line_values(line:line.chomp)
+      end
+    end
+
+    def self.tokenize_line(line:)
+      lines = line.split(FIELD_DELIMITER)
+      stripped = []
+      lines.each_with_index do |line, index|
+        if index == 0
+          stripped << line
+        else
+          stripped << line.strip
+        end
+      end
+      stripped
+    end
+
+    # returns two values
+    def self.line_and_index_for_beginning_with(lines:, string:)
+      lines.each_with_index do |line, index|
+        return line.chomp, index if line.start_with?(string)
+      end
+      return nil, -1
+    end
+
+    # Returns a hash of the key=value pairs found at the end of lines
+    def self.hash_from_line_values(line:)
+      tokens = self.tokenize_line(line: line)[2..-1]
+      hash = {}
+      tokens.each do |token|
+        key_value = token.split("=")
+        hash[key_value[0].to_sym] = key_value[1]
+      end
+      hash
+    end
+
+    def self.is_list_item?(line:)
+      if line && line.length != 0 && line.start_with?("\t")
+        true
+      else
+        false
+      end
+    end
+
+    def self.collect_list_items(lines:, start_index:)
+      items = []
+      index = start_index
+      loop do
+        line = lines[index]
+        if self.is_list_item?(line: line)
+          items << line.strip
+          index = index + 1
+        else
+          break
+        end
+      end
+      items
+    end
+
+    def self.label_and_translation(tokens:)
+      if tokens[0][/Claimed by/]
+        {label: "Claimed by", translation: tokens[1].split("'")[0].strip}
+      else
+        {label: tokens[0].split(":")[0], translation: tokens[1].split(":")[0] }
+      end
+    end
+
+    def self.camel_case_from_string(string:)
+      string.split(" ").map do |token|
+        token.capitalize
+      end.join("")
+    end
+
+    def self.snake_case_sym_from_string(string:)
+      string.split(" ").map do |token|
+        token.downcase
+      end.join("_").to_sym
+    end
+
+    def self.model_class_from_string(string:)
+      if !TFClient::Models.constants.include?(string.to_sym)
+        return nil
+      end
+
+      "TFClient::Models::#{string}".split("::").reduce(Object) do |obj, cls|
+        obj.const_get(cls)
+      end
+    end
+
+    attr_reader :command
+    attr_reader :textflight_command
+    attr_reader :response
+    attr_reader :lines
+
+    def initialize(command:, textflight_command:, response:)
+      @command = command
+      @textflight_command = textflight_command
+      @response = response
+    end
+
+    def parse
+      @lines = @response.lines(chomp: true).reject { |line| line.length == 0 }
+      case @textflight_command
+      when "nav"
+        parse_nav(command: @command)
+      when "scan"
+        parse_scan
+      when "status"
+        parse_status(command: @command)
+      else
+        if @response[/#{Models::STATUS_BEGIN}/]
+          @response = @lines[0].chomp
+          @lines = [@response]
+        end
+
+        puts ResponseParser.substitute_values(lines: @lines).join("\n")
+      end
+    end
+
+    def parse_nav(command:)
+      nav = TFClient::Models::Nav.new(lines: lines)
+      if command != "nav-for-prompt"
+        puts nav.response
+      end
+      nav
+    end
+
+    def parse_scan
+      scan = TFClient::Models::Scan.new(lines: lines)
+      puts scan.response
+      scan
+    end
+
+    def parse_status(command:)
+      if command == "status-for-prompt"
+        TFClient::Models::Status.new(lines: lines)
+      else
+        _, index_start =
+          ResponseParser.line_and_index_for_beginning_with(
+            lines: @lines,
+            string: Models::STATUS_BEGIN
+          )
+        if index_start == -1
+          puts ResponseParser.substitute_values(lines: @lines).join("\n")
+        end
+
+        _, index_end =
+          ResponseParser.line_and_index_for_beginning_with(
+            lines: @lines,
+            string: Models::STATUS_END
+          )
+
+        if index_start != 0
+          lines_before_status = @lines[0..index_start - 1]
+          puts ResponseParser.substitute_values(
+            lines: lines_before_status
+          ).join("\n")
+        else
+          lines_after_status = @lines[index_end + 1..-1]
+          puts ResponseParser.substitute_values(
+            lines: lines_after_status
+          ).join("\n")
+
+          Models::StatusReport.new(lines: @lines[index_start...index_end])
+        end
+      end
+    end
+  end
+end