textflight-client 1.0.1

data/lib/textflight-client.rb

@@ -0,0 +1,33 @@
+require "textflight-client/version"
+require "textflight-client/logging"
+require "textflight-client/environment"
+require "textflight-client/dot_dir"
+require "textflight-client/string_utils"
+require "textflight-client/command_parser"
+require "textflight-client/response_parser"
+require "textflight-client/models/model"
+require "textflight-client/models/nav"
+require "textflight-client/models/scan"
+require "textflight-client/models/status_report"
+require "textflight-client/models/status"
+require "textflight-client/models/local"
+require "textflight-client/tfprompt"
+
+module TFClient
+
+  # Prints a deprecated message that includes the line number.
+  #
+  # @param [String] version Indicates when the feature was deprecated.
+  # @param [String] msg Deprecation message (possibly suggesting alternatives)
+  # @return [void]
+  def self.deprecated(version, msg)
+
+    stack = Kernel.caller(0, 6)[1..-1].join("\n")
+
+    msg = "deprecated '#{version}' - #{msg}\n#{stack}"
+
+    $stderr.puts "\033[34mWARN: #{msg}\033[0m"
+    $stderr.flush
+  end
+
+end

data/lib/textflight-client/command_parser.rb

@@ -0,0 +1,42 @@
+module TFClient
+  class CommandParser
+
+    DIRECTION_MAP = {
+      n: "6",
+      ne: "7",
+      e: "4",
+      se: "2",
+      s: "1",
+      sw: "0",
+      w: "3",
+      nw: "5"
+    }
+
+    # 0: 315 degrees, X=-1, Y=-1 (northwest)
+    # 1: 0 degrees, X=0, Y=-1 (north)
+    # 2: 45 degrees, X=1, Y=-1 (northeast)
+    # 3: 270 degrees, X=-1, Y=0 (west)
+    # 4: 90 degrees, X=1, Y=0 (east)
+    # 5: 225 degrees, X=-1, Y=1 (southwest)
+    # 6: 180 degrees, X=0, Y=-1 (south)
+    # 7: 135 degrees, X=1, Y=-1 (southeast)
+
+    attr_reader :command
+    def initialize(command:)
+      @command = command
+    end
+
+    def parse
+      if @command == "quit" || @command == "exit"
+        return "exit"
+      end
+
+      direction = DIRECTION_MAP[@command.to_sym]
+      if direction
+        "jump #{direction}"
+      else
+        @command
+      end
+    end
+  end
+end

data/lib/textflight-client/dot_dir.rb

@@ -0,0 +1,21 @@
+
+module TFClient::DotDir
+
+  def self.directory
+    home = TFClient::Environment.user_home_directory
+    dir = File.join(home, ".textflight", "client")
+    if !File.exist?(dir)
+      FileUtils.mkdir_p(dir)
+    end
+    dir
+  end
+
+  def self.local_database_file(dev:)
+    if dev
+      File.expand_path(File.join(self.directory,"development.db"))
+    else
+      File.expand_path(File.join(self.directory,"production.db"))
+    end
+  end
+end
+

data/lib/textflight-client/environment.rb

@@ -0,0 +1,55 @@
+
+module TFClient
+  class Environment
+
+    # Returns the user home directory
+    def self.user_home_directory
+      require 'etc'
+      # If uid is omitted, the value from Passwd[:uid] is returned instead.
+      #noinspection RubyArgCount
+      Etc.getpwuid.dir
+    end
+
+    # Returns true if Windows environment
+    def self.windows_env?
+      if @@windows_env.nil?
+        @@windows_env = Environment.host_os_is_win?
+      end
+
+      @@windows_env
+    end
+
+    # Returns true if debugging is enabled.
+    def self.debug?
+      ENV['DEBUG'] == '1'
+    end
+
+    private
+
+    # !@visibility private
+    def self.ci_var_defined?
+      value = ENV["CI"]
+      !!value && value != ''
+    end
+
+
+    # @visibility private
+    WIN_PATTERNS = [
+      /bccwin/i,
+      /cygwin/i,
+      /djgpp/i,
+      /mingw/i,
+      /mswin/i,
+      /wince/i,
+    ]
+
+    # @!visibility private
+    @@windows_env = nil
+
+    # @!visibility private
+    def self.host_os_is_win?
+      ruby_platform = RbConfig::CONFIG["host_os"]
+      !!WIN_PATTERNS.find { |r| ruby_platform =~ r }
+    end
+  end
+end

data/lib/textflight-client/logging.rb

@@ -0,0 +1,58 @@
+
+module TFClient
+
+  # cyan
+  def self.log_unix_cmd(msg)
+    if ENV["DEBUG"] == "1"
+      puts Color.cyan("SHELL: #{msg}") if msg
+    end
+  end
+
+  # blue
+  def self.warn(msg)
+    puts Color.blue(" WARN: #{msg}") if msg
+  end
+
+  # magenta
+  def self.debug(msg)
+    if ENV["DEBUG"] == "1"
+      puts Color.magenta("DEBUG: #{msg}") if msg
+    end
+  end
+
+  # green
+  def self.info(msg)
+    puts Color.green(" INFO: #{msg}") if msg
+  end
+
+  # red
+  def self.error(msg)
+    puts Color.red("ERROR: #{msg}") if msg
+  end
+
+  module Color
+    def self.colorize(string, color)
+      "\033[#{color}m#{string}\033[0m"
+    end
+
+    def self.red(string)
+      colorize(string, 31)
+    end
+
+    def self.blue(string)
+      colorize(string, 34)
+    end
+
+    def self.magenta(string)
+      colorize(string, 35)
+    end
+
+    def self.cyan(string)
+      colorize(string, 36)
+    end
+
+    def self.green(string)
+      colorize(string, 32)
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+
+module TFClient
+  module Models
+    module Local
+      require "sequel"
+    end
+  end
+end
+
+module TFClient::Models::Local
+
+  require_relative "../../textflight-client/logging.rb"
+  require "json"
+
+  class Database
+
+    attr_reader :connection, :path
+
+    def initialize(path:)
+      @connection = Sequel.connect("sqlite://#{path}")
+
+      if !@connection.table_exists?(:systems)
+        @connection.create_table(:systems) do
+          primary_key :id
+          column :x, Integer
+          column :y, Integer
+          column :claimed_by, String
+          column :brightness, Integer
+          column :asteroid_ore, String
+          column :asteroid_density, Integer
+          column :links, String
+          column :planets, String
+        end
+      end
+    end
+
+    def system_for_id(id:)
+      table = @connection[:systems]
+      table.where(id: id)
+    end
+
+    def create_system(id:, nav:)
+      TFClient.info("creating a new system with id: #{id}")
+
+      links = nav.links.items.map do |link|
+        [link[:index], link[:direction], link[:drag], link[:faction]]
+      end
+
+      planets = nav.planets.items.map do |planet|
+        [planet[:index], planet[:type], planet[:name], planet[:faction]]
+      end
+
+      table = @connection[:systems]
+      table.insert(
+        {
+          id: id,
+          x: nav.coordinates.x,
+          y: nav.coordinates.y,
+          claimed_by: nav.claimed_by ? nav.claimed_by.faction : "",
+          brightness: nav.brightness.value,
+          asteroid_ore: nav.asteroids.ore,
+          asteroid_density: nav.asteroids.density,
+          links: JSON.generate(links),
+          planets: JSON.generate(planets)
+        }
+      )
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+
+module TFClient
+  module Models
+    require "cousin_roman"
+
+    TABLE_OPTIONS = { padding: [0,1,0,1], width: 80, resize: true }
+
+    class Response
+      attr_accessor :lines, :response
+
+      def initialize(lines:)
+        @lines = lines.dup
+        @response = []
+      end
+    end
+
+    class Model
+      attr_accessor :label, :translation, :values_hash
+
+      def initialize(line:)
+        tokens = ResponseParser.tokenize_line(line: line)
+        tokens_hash = ResponseParser.label_and_translation(tokens: tokens)
+        @label = tokens_hash[:label]
+        @translation = tokens_hash[:translation]
+        @values_hash = ResponseParser.hash_from_line_values(line: line)
+      end
+    end
+
+    class ModelWithItems < Model
+      require "tty-table"
+
+      attr_reader :items
+
+      def count
+        @items.count
+      end
+
+      def to_s
+        "#{@translation}: #{@items.map { |item| item[:string]}}"
+      end
+
+      def items_to_s
+        @items.map { |item| "\t#{item[:string]}" }
+      end
+
+      def response_str
+        "#{@translation}:\n#{items_to_s.join("\n")}"
+      end
+
+      def lines_offset
+        @items.length + 1
+      end
+    end
+  end
+end

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

@@ -0,0 +1,293 @@
+
+module TFClient
+  module Models
+    class Nav < Response
+
+      GAME_LINK_TO_COMPASS_MAP = {
+        "0" => "sw",
+        "1" => "s",
+        "2" => "se",
+        "3" => "w",
+        "4" => "e",
+        "5" => "nw",
+        "6" => "n",
+        "7" => "ne"
+      }
+
+      COMPASS_TO_GAME_LINK_MAP = {
+        "n" => 6,
+        "ne" => 7,
+        "e" => 4,
+        "se" => 2,
+        "s" => 1,
+        "sw" => 0,
+        "w" => 3,
+        "nw" => 5
+      }
+
+      COMPASS_ORDER = {
+        "n" => 0,
+        "ne" => 1,
+        "e" => 2,
+        "se" => 3,
+        "s" => 4,
+        "sw" => 5,
+        "w" => 6,
+        "nw" => 7
+      }
+
+      LINE_IDENTIFIER = [
+        "Coordinates",
+        "Claimed by",
+        "Brightness",
+        "Asteroids",
+        "Links",
+        "Planets",
+        "Structures"
+      ].freeze
+
+      attr_reader :coordinates, :claimed_by, :brightness, :asteroids
+      attr_reader :links, :planets, :structures
+
+      def initialize(lines:)
+        super(lines: lines)
+
+        LINE_IDENTIFIER.each_with_index do |label, label_index|
+          var_name = ResponseParser.snake_case_sym_from_string(string: label)
+          class_name = ResponseParser.camel_case_from_string(string: label)
+
+          clazz = ResponseParser.model_class_from_string(string: class_name)
+          if clazz.nil?
+            raise "could not find class name: #{class_name}"
+          end
+
+          line, _ = ResponseParser.line_and_index_for_beginning_with(lines: @lines,
+                                                                     string: label)
+
+          next if line.nil?
+
+          if label_index < 4
+            var = clazz.new(line: line)
+          else
+            var = clazz.new(lines: @lines)
+          end
+
+          instance_variable_set("@#{var_name}", var)
+        end
+      end
+
+      def response
+        puts @planets
+
+        puts @links
+        table = TTY::Table.new(rows: [[
+          "#{@brightness.to_s}",
+          "#{@asteroids.to_s}",
+          "#{@coordinates}"]
+        ])
+
+        puts table.render(:ascii, Models::TABLE_OPTIONS) do |renderer|
+          renderer.alignments= [:left, :center, :right]
+        end
+
+        puts @structures
+      end
+
+      def to_s
+        "#<Nav: #{@coordinates.to_s}>"
+      end
+    end
+
+    class Coordinates < Model
+      attr_reader :x, :y
+
+      def initialize(line:)
+        super(line: line)
+        @x = @values_hash[:x].to_i
+        @y = @values_hash[:y].to_i
+      end
+
+      def to_s
+        %Q[#{@translation}: (#{@x},#{@y})]
+      end
+    end
+
+    class ClaimedBy < Model
+      attr_reader :faction
+
+      def initialize(line:)
+        super(line: line)
+        @faction = @values_hash[:faction]
+      end
+
+      def to_s
+        %Q[#{@translation} '#{@faction}']
+      end
+    end
+
+    class Brightness < Model
+      attr_reader :value, :percent
+
+      def initialize(line:)
+        super(line: line)
+        @value = @values_hash[:brightness].to_i
+        @percent = ((@value/255.0) * 100).round
+      end
+
+      def to_s
+        %Q[#{@translation}: #{@value} => #{@percent}%]
+      end
+    end
+
+    class Asteroids < Model
+      attr_reader :ore, :density, :percent
+
+      def initialize(line:)
+        super(line: line)
+        @ore = @values_hash[:asteroid_type]
+        @density = @values_hash[:asteroid_density].to_i
+        @percent = ((@density/7.0) * 100).round
+      end
+
+      def to_s
+        %Q[#{@translation}: #{@ore} (#{@density}) => #{@percent}%]
+      end
+    end
+
+    class Links < ModelWithItems
+      def initialize(lines:)
+        line, index = ResponseParser.line_and_index_for_beginning_with(lines: lines,
+                                                                       string: "Links")
+        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
+          faction = hash[:faction]
+          drag = hash[:link_drag].to_i
+
+          # direction is WIP
+          direction = Nav::GAME_LINK_TO_COMPASS_MAP[index.to_s]
+          {
+            index: index, drag: drag, direction: direction, faction: faction
+          }
+        end.sort do |a, b|
+          Nav::COMPASS_ORDER[a[:direction]] <=> Nav::COMPASS_ORDER[b[:direction]]
+        end
+      end
+
+      def to_s
+        table = TTY::Table.new(header: [
+          {value: "#{@translation}", alignment: :right},
+          {value: "drag", alignment: :center},
+          {value: "faction", alignment: :center},
+          {value: "original", alignment: :center},
+          {value: "direction", alignment: :center}
+        ])
+
+        @items.each do |item|
+          table << [
+            "#{item[:direction]}",
+            item[:drag],
+            item[:faction],
+            "[#{item[:index]}]",
+            "#{item[:direction]}"
+          ]
+        end
+
+        table.render(:ascii, Models::TABLE_OPTIONS) do |renderer|
+          renderer.alignments= [:right, :right, :center, :center, :center, :center]
+        end
+      end
+    end
+
+    class Planets < ModelWithItems
+
+      def initialize(lines:)
+        line, index = ResponseParser.line_and_index_for_beginning_with(lines: lines,
+                                                                       string: "Planets")
+        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
+          type = hash[:planet_type]
+          name = hash[:name]
+          faction = hash[:faction]
+
+          { index: index, type: type, name: name, faction: faction }
+        end
+      end
+
+      def to_s
+        return "" if @items.empty?
+        table = TTY::Table.new(header: [
+          {value: "#{@translation}", alignment: :right},
+          {value: "type", alignment: :center},
+          {value: "name", alignment: :center},
+          {value: "faction", alignment: :center},
+          {value: "index", alignment: :center}
+        ])
+
+        @items.each do |item|
+          table << [
+            "[#{item[:index]}]",
+            item[:type],
+            item[:name],
+            item[:faction],
+            "[#{item[:index]}]"
+          ]
+        end
+
+        table.render(:ascii, Models::TABLE_OPTIONS) do |renderer|
+          renderer.alignments= [:right, :right, :center, :center, :center]
+        end
+      end
+    end
+
+    class Structures < ModelWithItems
+
+        def initialize(lines:)
+          line, index = ResponseParser.line_and_index_for_beginning_with(lines: lines,
+                                                                         string: "Structures")
+        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)
+
+          id = hash[:id].to_i
+          name = hash[:name]
+          # TODO: distinguish shipyards from bases
+          type = hash[:sclass] || "base"
+          { id: id, name: name, type: type }
+        end
+      end
+
+      def to_s
+        table = TTY::Table.new(header: [
+          {value: "#{@translation}", alignment: :right},
+          {value: "name", alignment: :center},
+          {value: "ship class", alignment: :center},
+          {value: "id", alignment: :center }
+        ])
+
+        @items.each do |item|
+          table << ["[#{item[:id]}]", item[:name], item[:type], "[#{item[:id]}]"]
+        end
+
+        table.render(:ascii, Models::TABLE_OPTIONS) do |renderer|
+          renderer.alignments= [:right, :right, :center, :center]
+        end
+      end
+    end
+  end
+end