openra 0.3.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d4b0cd4fc230f79bfb083fb98c4adba801016c57
-  data.tar.gz: 6e69e56820305fd0868b959b9787e0b15e52b50b
+  metadata.gz: 18eaa1cb9a89b397783943143d5038abf81eaa2a
+  data.tar.gz: 8d0656389b17e73063eb24973326921a68e3e845
 SHA512:
-  metadata.gz: 8a5b42b78584c3b2a5ca4afbbd53e793c0bf0e357df0e250ff0e1801c731928eb97cabb8f84e04662128a770b6c44a0af759e06a073f15606fec1087a33b21aa
-  data.tar.gz: 440ce52d27cc21c42b18d399b550b5ae22580c5e1fbd50f70256333426dfaac5af0bbb34239cc99f0d22597513cc07a4baef739568c8095af46f0477a68a657a
+  metadata.gz: a3889a2bdbb19f65e091e18bfc6168de0442c9c6c790c57024cb9a2e442b40754ee6234d139f83376e3e90168551da58a289e6fadbcd3e06b4312c393de9b4be
+  data.tar.gz: a99959ea027d0e554871bf05485df7794ba7dec96d235b778efea5fb13703764b6e7d4add86dc07225afb35315781a00ea9aaccbfbe56c5b98793eaa677e26d5

data/CHANGELOG.md

@@ -1,11 +1,25 @@
 ## Unreleased
 
+## Added
+
+* [core] Clean up internals with structs and better abstractions ([AMHOL](https://github.com/AMHOL))
+* [replay-data] Added duration struct to game output (formatted/msec) ([AMHOL](https://github.com/AMHOL))
+* [replay-data] Added support for YAML output format ([AMHOL](https://github.com/AMHOL))
+
+## Removed
+
+* [replay-data] Removed duration (seconds) field from game output ([AMHOL](https://github.com/AMHOL))
+
+[Compare v0.3.0...HEAD](https://github.com/AMHOL/openra-ruby/compare/v0.3.0...HEAD)
+
+## v0.3.0
+
 ## Fixed
 
 * [replay-data] Fix "type" output when no teams set ([AMHOL](https://github.com/AMHOL))
 * [replay-data] Fix error uninitialized constant Openra::CLI::Commands::ReplayData::SecureRandom ([AMHOL](https://github.com/AMHOL))
 
-[Compare v0.2.0...HEAD](https://github.com/AMHOL/openra-ruby/compare/v0.2.0...HEAD)
+[Compare v0.2.0...v0.3.0](https://github.com/AMHOL/openra-ruby/compare/v0.2.0...v0.3.0)
 
 ## v0.2.0
 

data/lib/openra-replays.rb

@@ -0,0 +1 @@
+require 'openra/replays'

data/lib/openra-struct.rb

@@ -0,0 +1 @@
+require 'openra/struct'

data/lib/openra-types.rb

@@ -0,0 +1 @@
+require 'openra/types'

data/lib/openra-yaml.rb

@@ -0,0 +1 @@
+require 'openra/yaml

data/lib/openra.rb

@@ -1,2 +1,2 @@
 require 'openra/version'
-require 'openra/replays'
+require 'openra/replays' # Replays requires everything else

data/lib/openra/cli.rb

@@ -1,5 +1,12 @@
+require 'securerandom'
+require 'yaml'
+require 'json'
 require 'hanami/cli'
-require 'openra'
+require 'openra/version'
+require 'openra/replays'
+require 'openra/cli/commands/replay_data/formatters'
+require 'openra/cli/commands/replay_data'
+require 'openra/cli/commands/version'
 require 'openra/cli/command_registry'
 
 module Openra

data/lib/openra/cli/command_registry.rb

@@ -1,6 +1,3 @@
-require 'openra/cli/commands/replay_data'
-require 'openra/cli/commands/version'
-
 module Openra
   class CLI
     class CommandRegistry

data/lib/openra/cli/commands/replay_data.rb

@@ -1,190 +1,140 @@
-require 'json'
-require 'securerandom'
-
 module Openra
   class CLI
     module Commands
       class ReplayData < Hanami::CLI::Command
-        ORDER_LATENCY_MAPPING = {
-          'slowest' => 2,
-          'slower' => 3,
-          'default' => 3,
-          'fast' => 4,
-          'faster' => 4,
-          'fastest' => 6
+        FORMATTERS = {
+          'json' => Formatters::JSON.new,
+          'pretty-json' => Formatters::PrettyJSON.new,
+          'yaml' => Formatters::YAML.new,
         }.freeze
 
         desc 'Output replay data to stdout'
 
         argument :replay, required: true, desc: 'Path of the replay file to read data from'
-        option :format, default: 'json', values: %w(json pretty-json), desc: 'Output format'
+        option :format, default: 'json', values: %w(json pretty-json yaml), desc: 'Output format'
 
         def call(replay:, **options)
           replay = Openra::Replays::Replay.new(replay)
 
-          players = replay.metadata.each_with_object([]) do |(key, value), arr|
-            next unless key.start_with?('Player')
-            arr << value
-          end
-          player_mapping = players.each_with_object({}) do |player, mapping|
-            mapping[player['ClientIndex']] = player
-          end
-          player_teams = players.map { |player| player['Team'] }
-          team_alignment = player_teams.each_with_object({}) do |team, hash|
-            if team.to_s == '0'
-              hash[SecureRandom.uuid] = 1
-            else
-              hash[team] ||= 0
-              hash[team] += 1
-            end
-          end
-
           replay_data = {
-            mod: replay.mod,
-            version: replay.version,
-            server_name: nil,
+            mod: replay.metadata.mod,
+            version: replay.metadata.version,
+            server_name: utf8(replay.global_settings.server_name),
             map: {
-              name: utf8(replay.map_title),
-              hash: replay.map_id
+              name: utf8(replay.metadata.map_name),
+              hash: replay.metadata.map_hash
             },
             game: {
-              type: team_alignment.values.join('v'),
-              start_time: replay.start_time,
-              end_time: replay.end_time,
-              duration: replay.duration,
-              options: {}
+              type: replay.clients.each_with_object(Hash.new(0)) { |client, hash|
+                if client.team.nil?
+                  hash[SecureRandom.uuid] += 1
+                else
+                  hash[client.team] += 1
+                end
+              }.values.join('v'),
+              start_time: replay.metadata.start_time,
+              end_time: replay.metadata.end_time,
+              duration: time((replay.metadata.end_time - replay.metadata.start_time) * 1000),
+              options: {
+                explored_map: replay.game_options.explored_map_enabled.value,
+                speed: replay.game_options.game_speed.value,
+                starting_cash: replay.game_options.starting_cash.value,
+                starting_units: replay.game_options.starting_units.value,
+                fog_enabled: replay.game_options.fog_enabled.value,
+                cheats_enabled: replay.game_options.cheats_enabled.value,
+                kill_bounty_enabled: replay.game_options.bounties_enabled.value,
+                allow_undeploy: replay.game_options.conyard_undeploy_enabled.value,
+                crates_enabled: replay.game_options.crates_enabled.value,
+                build_off_allies: replay.game_options.build_off_allies_enabled.value,
+                restrict_build_radius: replay.game_options.restricted_build_radius_enabled.value,
+                short_game: replay.game_options.short_game_enabled.value,
+                techlevel: replay.game_options.tech_level.value
+              }
+            },
+            clients: replay.clients.map { |client|
+              player = replay.player(client.index)
+
+              {
+                index: client.index,
+                name: utf8(client.name),
+                preferred_color: client.preferred_color,
+                color: client.preferred_color,
+                spawn: {
+                  random: player&.is_random_spawn,
+                  point: client.spawn_point
+                },
+                faction: {
+                  chosen: client.faction_name.downcase,
+                  actual: player&.faction_id
+                },
+                ip: client.ip,
+                team: player&.team,
+                is_bot: player&.is_bot || false,
+                is_admin: client.is_admin,
+                is_player: !player.nil?,
+                is_winner: player&.outcome == 'Won',
+                build: []
+              }
             },
-            clients: [],
             chat: []
           }
 
-          timestep = nil
-          sync_info_orders = replay.orders.select do |order|
-            order.command == 'SyncInfo'
-          end
-
-          sync_info_orders.reverse.each.with_index do |sync_info_order, index|
-            sync_info = Openra::YAML.load(sync_info_order.target)
-
-            # Get all clients
-            sync_info.each_pair do |key, data|
-              case key
-              when /^Client@/
-                player = player_mapping.fetch(data['Index'], {})
-
-                replay_data[:clients] << {
-                  index: data['Index'],
-                  name: utf8(data['Name']),
-                  preferred_color: data['PreferredColor'],
-                  color: data['Color'],
-                  spawn: {
-                    random: player.fetch('IsRandomSpawnPoint', 'False') == 'True',
-                    point: player.fetch('SpawnPoint', nil)
-                  },
-                  faction: {
-                    chosen: data['Faction'].downcase,
-                    actual: player_mapping.fetch(data['Index'], {}).fetch('FactionId', nil)
-                  },
-                  ip: data['IpAddress'],
-                  team: player.fetch('Team', '0').to_s == '0' ? nil : data['Team'],
-                  is_bot: data['Bot'].nil? ? false : true,
-                  is_admin: data['IsAdmin'] == 'True',
-                  is_player: !player.empty?,
-                  is_winner: player.fetch('Outcome', nil) == 'Won',
-                  build: []
-                } unless replay_data[:clients].any? { |client| client[:index] == data['Index'] }
-              when 'GlobalSettings'
-                next unless index.zero?
-
-                timestep = Integer(data['Timestep']) * ORDER_LATENCY_MAPPING.fetch(
-                  data['Options']['gamespeed']['Value'],
-                  ORDER_LATENCY_MAPPING['default']
-                )
-
-                replay_data[:server_name] = data['ServerName']
-                replay_data[:game][:options] = {
-                  explored_map: data['Options']['explored']['Value'] == 'True',
-                  speed: data['Options']['gamespeed']['Value'],
-                  starting_cash: data['Options']['startingcash']['Value'],
-                  starting_units: data['Options']['startingunits']['Value'],
-                  fog_enabled: data['Options']['fog']['Value'] == 'True',
-                  cheats_enabled: data['Options']['cheats']['Value'] == 'True',
-                  kill_bounty_enabled: data['Options']['bounty']['Value'] == 'True',
-                  allow_undeploy: data['Options']['factundeploy']['Value'] == 'True',
-                  crates_enabled: data['Options']['crates']['Value'] == 'True',
-                  build_off_allies: data['Options']['allybuild']['Value'] == 'True',
-                  restrict_build_radius: data['Options']['buildradius']['Value'] == 'True',
-                  short_game: data['Options']['shortgame']['Value'] == 'True',
-                  techlevel: data['Options']['techlevel']['Value']
-                }
-              end
-            end
-          end
-
           replay.orders.each do |order|
+            client = replay.client(order.client_index.to_s)
+
             case order.command
             when 'PlaceBuilding'
-              client = replay_data[:clients].find do |candidate|
+              client_hash = replay_data[:clients].find do |candidate|
                 candidate[:index] == order.client_index.to_s
               end
 
-              current_time = order.frame * timestep
-              current_time_seconds = current_time / 1000
-              mm, ss = current_time_seconds.divmod(60)
-              hh, mm = mm.divmod(60)
-
-              client[:build] << {
-                structure: order.target_string,
-                game_time: {
-                  formatted: '%02d:%02d:%02d' % [hh, mm, ss],
-                  msec: current_time
-                },
+              client_hash[:build] << {
+                structure: utf8(order.target_string),
+                game_time: time(order.frame * replay.frametime_multiplier),
                 placement: {
-                  x: order.target_x,
-                  y: order.target_y
+                  x: order.target_x.to_i,
+                  y: order.target_y.to_i
                 }
               }
             when 'Message'
               replay_data[:chat] << {
-                channel: :server,
+                channel: 'server',
                 name: nil,
                 message: utf8(order.target)
               }
             when 'Chat'
-              client = replay_data[:clients].find do |candidate|
-                candidate[:index] == order.client_index.to_s
-              end
-
               replay_data[:chat] << {
-                channel: :global,
-                name: client[:name],
+                channel: 'global',
+                name: client.name,
                 message: utf8(order.target)
               }
             when 'TeamChat'
-              client = replay_data[:clients].find do |candidate|
-                candidate[:index] == order.client_index.to_s
-              end
-
               replay_data[:chat] << {
-                channel: client[:team],
-                name: client[:name],
+                channel: client.team,
+                name: client.name,
                 message: utf8(order.target)
               }
             end
           end
 
-          case options[:format]
-          when 'json'
-            puts JSON.dump(replay_data)
-          when 'pretty-json'
-            puts JSON.pretty_generate(replay_data)
-          end
+          puts FORMATTERS.fetch(options[:format]).call(replay_data)
         end
 
         private
 
         def utf8(string)
-          string.force_encoding('UTF-8')
+          string.force_encoding('UTF-8').to_s
+        end
+
+        def time(msec)
+          sec = msec / 1000
+          mm, ss = sec.divmod(60)
+          hh, mm = mm.divmod(60)
+
+          {
+            formatted: '%02d:%02d:%02d' % [hh, mm, ss],
+            msec: msec.to_i
+          }
         end
       end
     end

data/lib/openra/cli/commands/replay_data/formatters.rb

@@ -0,0 +1,29 @@
+module Openra
+  class CLI
+    module Commands
+      class ReplayData < Hanami::CLI::Command
+        module Formatters
+          class JSON
+            def call(data)
+              ::JSON.dump(data)
+            end
+          end
+
+          class PrettyJSON
+            def call(data)
+              ::JSON.pretty_generate(data)
+            end
+          end
+
+          class YAML
+            def call(data)
+              ::YAML.dump(
+                Openra::Struct::Functions[:deep_stringify_keys].(data)
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openra/replays.rb

@@ -1,8 +1,9 @@
 require 'date'
 require 'bindata'
-require 'big_integer'
-require 'pascal_string'
+require 'bindata/big_integer'
+require 'bindata/pascal_string'
 require 'openra/yaml'
+require 'openra/struct'
 require 'openra/replays/order_decorator'
 require 'openra/replays/order'
 require 'openra/replays/order_list'

data/lib/openra/replays/replay.rb

@@ -8,45 +8,68 @@ module Openra
       end
 
       def metadata
-        @metadata ||= Openra::YAML.load(file.metadata.data)
+        @metadata ||= Openra::Struct::Metadata.new(
+          Openra::YAML.load(file.metadata.data)
+        )
       end
 
       def orders
         @orders ||= file.orders
       end
 
-      def mod
-        @mod ||= metadata['Root']['Mod']
+      def players
+        metadata.players
       end
 
-      def version
-        @version ||= metadata['Root']['Version']
+      def player(index)
+        players.find do |candidate|
+          candidate.index == index
+        end
       end
 
-      def map_id
-        @map_id ||= metadata['Root']['MapUid']
+      def clients
+        sync_info.clients
       end
 
-      def map_title
-        @map_title ||= metadata['Root']['MapTitle']
+      def client(index)
+        clients.find do |candidate|
+          candidate.index == index
+        end
       end
 
-      def start_time
-        @start_time ||= ::DateTime.strptime(
-          metadata['Root']['StartTimeUtc'],
-          '%Y-%m-%d %H-%M-%S'
-        ).to_time
+      def global_settings
+        sync_info.global_settings
       end
 
-      def end_time
-        @end_time ||= ::DateTime.strptime(
-          metadata['Root']['EndTimeUtc'],
-          '%Y-%m-%d %H-%M-%S'
-        ).to_time
+      def frametime_multiplier
+        global_settings.frametime_multiplier
       end
 
-      def duration
-        @duration ||= (end_time - start_time).to_i
+      def game_options
+        global_settings.game_options
+      end
+
+      private
+
+      def sync_info
+        return @sync_info if @sync_info
+
+        syncs = orders.reverse.each_with_object([]) do |order, arr|
+          next unless order.command == 'SyncInfo'
+
+          arr << Openra::Struct::SyncInfo.new(
+            Openra::YAML.load(order.target)
+          )
+        end
+
+        @sync_info = syncs.inject(syncs.shift) do |next_sync, sync|
+          next_sync.clients.each do |client|
+            next if sync.clients.map(&:index).include?(client.index)
+            sync.clients << client
+          end
+
+          sync
+        end
       end
     end
   end

data/lib/openra/struct.rb

@@ -0,0 +1,49 @@
+require 'transproc'
+require 'dry-struct'
+require 'openra/types'
+require 'openra/struct/functions'
+require 'openra/struct/pre_processor'
+
+module Openra
+  class Struct < Dry::Struct
+    UNDEFINED = Object.new.freeze
+    DEFAULT_PROCESSOR = PreProcessor.new
+
+    class << self
+      def preprocessor(processor = UNDEFINED)
+        if processor === UNDEFINED
+          @__preprocessor || DEFAULT_PROCESSOR
+        else
+          @__preprocessor = processor
+        end
+      end
+
+      def inherited(subclass)
+        super
+        subclass.preprocessor(preprocessor)
+      end
+
+      def define(&block)
+        instance_eval(&block)
+
+        preprocessor(preprocessor.with(schema: schema))
+
+        preprocessor.finalize!
+      end
+
+      def new(attributes)
+        super(preprocessor.call(attributes))
+      end
+    end
+  end
+end
+
+require 'openra/struct/client'
+require 'openra/struct/player'
+require 'openra/struct/game_options/boolean_option'
+require 'openra/struct/game_options/integer_option'
+require 'openra/struct/game_options/string_option'
+require 'openra/struct/game_options'
+require 'openra/struct/global_settings'
+require 'openra/struct/sync_info'
+require 'openra/struct/metadata'

data/lib/openra/struct/client.rb

@@ -0,0 +1,26 @@
+module Openra
+  class Struct < Dry::Struct
+    class Client < Openra::Struct
+      define do
+        attribute :index, Types::Strict::String.meta(from: 'Index')
+        attribute :preferred_color, Types::Strict::String.meta(from: 'PreferredColor')
+        attribute :color, Types::Strict::String.meta(from: 'Color')
+        attribute :faction_name, Types::Strict::String.meta(from: 'Faction')
+        attribute :spawn_point, Types::Strict::String.meta(from: 'SpawnPoint')
+        attribute :name, Types::Strict::String.meta(from: 'Name')
+        attribute :ip, Types::Strict::String.meta(from: 'IpAddress')
+        attribute :state, Types::Strict::String.meta(from: 'State')
+        attribute :team, Types::Strict::String.meta(from: 'Team')
+        attribute :slot, Types::Strict::String.meta(from: 'Slot', omittable: true)
+        attribute :bot_controller_index, Types::Strict::String.meta(
+          from: 'BotControllerClientIndex'
+        )
+        attribute :is_admin, Types::Params::Bool.meta(from: 'IsAdmin')
+      end
+
+      def team
+        attributes[:team] == '0' ? nil : attributes[:team]
+      end
+    end
+  end
+end

data/lib/openra/struct/functions.rb

@@ -0,0 +1,33 @@
+module Openra
+  class Struct < Dry::Struct
+    module Functions
+      extend Transproc::Registry
+
+      import Transproc::HashTransformations
+
+      def self.sequence(hash, prefix, into)
+        keys = hash.keys.select { |key| key.start_with?(prefix + '@') }
+
+        hash[into] = keys.map { |key| hash[key] }
+
+        hash
+      end
+
+      def self.deep_stringify_keys(hash)
+        hash.each_with_object({}) do |(key, value), output|
+          output[key.to_s] =
+            case value
+            when Hash
+              deep_stringify_keys(value)
+            when Array
+              value.map { |item|
+                item.is_a?(Hash) ? deep_stringify_keys(item) : item
+              }
+            else
+              value
+            end
+        end
+      end
+    end
+  end
+end

data/lib/openra/struct/game_options.rb

@@ -0,0 +1,42 @@
+module Openra
+  class Struct < Dry::Struct
+    class GameOptions < Openra::Struct
+      define do
+        attribute :starting_cash, IntegerOption.meta(from: 'startingcash')
+        attribute :cheats_enabled, BooleanOption.meta(from: 'cheats')
+        attribute :explored_map_enabled, BooleanOption.meta(from: 'explored')
+        attribute :fog_enabled, BooleanOption.meta(from: 'fog')
+        attribute :bounties_enabled, BooleanOption.meta(from: 'bounty', omittable: true)
+        attribute :conyard_undeploy_enabled, BooleanOption.meta(from: 'factundeploy', omittable: true)
+        attribute :crates_enabled, BooleanOption.meta(from: 'crates')
+        attribute :build_off_allies_enabled, BooleanOption.meta(from: 'allybuild')
+        attribute :restricted_build_radius_enabled, BooleanOption.meta(from: 'buildradius', omittable: true)
+        attribute :short_game_enabled, BooleanOption.meta(from: 'shortgame')
+        attribute :tech_level, StringOption.meta(from: 'techlevel')
+        attribute :game_speed, StringOption.meta(from: 'gamespeed')
+        attribute :starting_units, StringOption.meta(from: 'startingunits')
+      end
+
+      def bounties_enabled
+        attributes.fetch(:bounties_enabled, BooleanOption.new(
+          value: true,
+          preferred_value: true
+        ))
+      end
+
+      def conyard_undeploy_enabled
+        attributes.fetch(:conyard_undeploy_enabled, BooleanOption.new(
+          value: true,
+          preferred_value: true
+        ))
+      end
+
+      def restricted_build_radius_enabled
+        attributes.fetch(:restricted_build_radius_enabled, BooleanOption.new(
+          value: true,
+          preferred_value: true
+        ))
+      end
+    end
+  end
+end

data/lib/openra/struct/game_options/boolean_option.rb

@@ -0,0 +1,14 @@
+module Openra
+  class Struct < Dry::Struct
+    class GameOptions < Openra::Struct
+      class BooleanOption < Openra::Struct
+        define do
+          attribute :value, Types::Params::Bool.meta(from: 'Value')
+          attribute :preferred_value, Types::Params::Bool.meta(
+            from: 'PreferredValue'
+          )
+        end
+      end
+    end
+  end
+end

data/lib/openra/struct/game_options/integer_option.rb

@@ -0,0 +1,14 @@
+module Openra
+  class Struct < Dry::Struct
+    class GameOptions < Openra::Struct
+      class IntegerOption < Openra::Struct
+        define do
+          attribute :value, Types::Params::Integer.meta(from: 'Value')
+          attribute :preferred_value, Types::Params::Integer.meta(
+            from: 'PreferredValue'
+          )
+        end
+      end
+    end
+  end
+end

data/lib/openra/struct/game_options/string_option.rb

@@ -0,0 +1,14 @@
+module Openra
+  class Struct < Dry::Struct
+    class GameOptions < Openra::Struct
+      class StringOption < Openra::Struct
+        define do
+          attribute :value, Types::Strict::String.meta(from: 'Value')
+          attribute :preferred_value, Types::Strict::String.meta(
+            from: 'PreferredValue'
+          )
+        end
+      end
+    end
+  end
+end

data/lib/openra/struct/global_settings.rb

@@ -0,0 +1,22 @@
+module Openra
+  class Struct < Dry::Struct
+    class GlobalSettings < Openra::Struct
+      define do
+        attribute :server_name, Types::Strict::String.meta(from: 'ServerName')
+        attribute :map_hash, Types::Strict::String.meta(from: 'Map')
+        attribute :timestep, Types::Params::Integer.meta(from: 'Timestep')
+        attribute :order_latency, Types::Params::Integer.meta(from: 'OrderLatency')
+        attribute :random_seed, Types::Strict::String.meta(from: 'RandomSeed')
+        attribute :allow_spectators, Types::Params::Bool.meta(from: 'AllowSpectators')
+        attribute :allow_version_mismatch, Types::Params::Bool.meta(from: 'AllowVersionMismatch')
+        attribute :allow_singleplayer, Types::Params::Bool.meta(from: 'EnableSingleplayer')
+        attribute :game_id, Types::Strict::String.meta(from: 'GameUid')
+        attribute :game_options, GameOptions.meta(from: 'Options')
+      end
+
+      def frametime_multiplier
+        timestep * order_latency
+      end
+    end
+  end
+end

data/lib/openra/struct/metadata.rb

@@ -0,0 +1,17 @@
+module Openra
+  class Struct < Dry::Struct
+    class Metadata < Openra::Struct
+      preprocessor(preprocessor.with(root: 'Root'))
+
+      define do
+        attribute :mod, Types::Strict::String.meta(from: 'Mod')
+        attribute :version, Types::Strict::String.meta(from: 'Version')
+        attribute :map_hash, Types::Strict::String.meta(from: 'MapUid')
+        attribute :map_name, Types::Strict::String.meta(from: 'MapTitle')
+        attribute :start_time, Types::Timestamp.meta(from: 'StartTimeUtc')
+        attribute :end_time, Types::Timestamp.meta(from: 'EndTimeUtc')
+        attribute :players, Types::Strict::Array.of(Player).meta(sequence: 'Player')
+      end
+    end
+  end
+end

data/lib/openra/struct/player.rb

@@ -0,0 +1,25 @@
+module Openra
+  class Struct < Dry::Struct
+    class Player < Openra::Struct
+      define do
+        attribute :index, Types::Strict::String.meta(from: 'ClientIndex')
+        attribute :name, Types::Strict::String.meta(from: 'Name')
+        attribute :is_human, Types::Params::Bool.meta(from: 'IsHuman')
+        attribute :is_bot, Types::Params::Bool.meta(from: 'IsBot')
+        attribute :faction_name, Types::Strict::String.meta(from: 'FactionName')
+        attribute :faction_id, Types::Strict::String.meta(from: 'FactionId')
+        attribute :color, Types::Strict::String.meta(from: 'Color')
+        attribute :team, Types::Strict::String.meta(from: 'Team')
+        attribute :spawn_point, Types::Strict::String.meta(from: 'SpawnPoint')
+        attribute :is_random_faction, Types::Params::Bool.meta(from: 'IsRandomFaction')
+        attribute :is_random_spawn, Types::Params::Bool.meta(from: 'IsRandomSpawnPoint')
+        attribute :outcome, Types::Strict::String.meta(from: 'Outcome')
+        attribute :outcome_time, Types::Timestamp.meta(from: 'OutcomeTimestampUtc')
+      end
+
+      def team
+        attributes[:team] == '0' ? nil : attributes[:team]
+      end
+    end
+  end
+end

data/lib/openra/struct/pre_processor.rb

@@ -0,0 +1,67 @@
+module Openra
+  class Struct < Dry::Struct
+    class PreProcessor
+      AlreadyFinalizedError = Class.new(StandardError)
+      NotFinalizedError = Class.new(StandardError)
+
+      attr_reader :config
+
+      def initialize(**config)
+        @config = config
+      end
+
+      def call(input)
+        transformer.call(input)
+      end
+
+      def with(**new_config)
+        raise AlreadyFinalizedError, 'transformer already finalized' if finalized?
+        self.class.new(config.merge(new_config))
+      end
+
+      def finalize!
+        config = self.config
+
+        transformer_klass = Class.new(Transproc::Transformer[Functions])
+        transformer_klass.instance_eval do
+          unwrap(config[:root]) if config[:root]
+
+          if (schema = config[:schema])
+            schema.each_pair do |key, type|
+              if (sequence = type.meta[:sequence])
+                sequence(sequence, sequence)
+                rename_keys(sequence => key)
+              end
+            end
+
+            mapping = schema.each_with_object({}) do |(key, type), mapping|
+              mapping[type.meta[:from]] = key if type.meta[:from]
+            end
+
+            rename_keys(mapping)
+          end
+        end
+
+        @transformer = transformer_klass.new
+        @finalized = true
+      end
+
+      private
+
+      def transformer
+        if finalized?
+          @transformer
+        else
+          raise(
+            NotFinalizedError,
+            'preprocessor must be finalized before being used'
+          )
+        end
+      end
+
+      def finalized?
+        @finalized == true
+      end
+    end
+  end
+end

data/lib/openra/struct/sync_info.rb

@@ -0,0 +1,12 @@
+module Openra
+  class Struct < Dry::Struct
+    class SyncInfo < Openra::Struct
+      define do
+        attribute :clients, Types::Strict::Array.of(Client).meta(sequence: 'Client')
+        attribute :global_settings, GlobalSettings.meta(
+          from: 'GlobalSettings'
+        )
+      end
+    end
+  end
+end

data/lib/openra/types.rb

@@ -0,0 +1,11 @@
+require 'dry-types'
+
+module Openra
+  module Types
+    include Dry::Types.module
+
+    Timestamp = Constructor(Time) do |input|
+      ::DateTime.strptime(input, '%Y-%m-%d %H-%M-%S').to_time
+    end
+  end
+end

data/lib/openra/version.rb

@@ -1,3 +1,3 @@
 module Openra
-  VERSION = '0.3.0'.freeze
+  VERSION = '1.0.0'.freeze
 end

data/openra.gemspec

@@ -16,6 +16,9 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'bindata', '2.4.3'
+  spec.add_dependency 'transproc', '1.0.2'
+  spec.add_dependency 'dry-types', '0.13.2'
+  spec.add_dependency 'dry-struct', '0.5.0'
   spec.add_dependency 'hanami-cli', '0.2.0'
 
   spec.add_development_dependency 'bundler'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: openra
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Andy Holland
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-30 00:00:00.000000000 Z
+date: 2018-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bindata
@@ -24,6 +24,48 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 2.4.3
+- !ruby/object:Gem::Dependency
+  name: transproc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+- !ruby/object:Gem::Dependency
+  name: dry-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.13.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.13.2
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.0
 - !ruby/object:Gem::Dependency
   name: hanami-cli
   requirement: !ruby/object:Gem::Requirement
@@ -81,12 +123,18 @@ files:
 - README.md
 - Rakefile
 - bin/openra
-- lib/big_integer.rb
+- lib/bindata/big_integer.rb
+- lib/bindata/pascal_string.rb
 - lib/openra-cli.rb
+- lib/openra-replays.rb
+- lib/openra-struct.rb
+- lib/openra-types.rb
+- lib/openra-yaml.rb
 - lib/openra.rb
 - lib/openra/cli.rb
 - lib/openra/cli/command_registry.rb
 - lib/openra/cli/commands/replay_data.rb
+- lib/openra/cli/commands/replay_data/formatters.rb
 - lib/openra/cli/commands/version.rb
 - lib/openra/replays.rb
 - lib/openra/replays/file.rb
@@ -98,9 +146,21 @@ files:
 - lib/openra/replays/packet.rb
 - lib/openra/replays/packet_list.rb
 - lib/openra/replays/replay.rb
+- lib/openra/struct.rb
+- lib/openra/struct/client.rb
+- lib/openra/struct/functions.rb
+- lib/openra/struct/game_options.rb
+- lib/openra/struct/game_options/boolean_option.rb
+- lib/openra/struct/game_options/integer_option.rb
+- lib/openra/struct/game_options/string_option.rb
+- lib/openra/struct/global_settings.rb
+- lib/openra/struct/metadata.rb
+- lib/openra/struct/player.rb
+- lib/openra/struct/pre_processor.rb
+- lib/openra/struct/sync_info.rb
+- lib/openra/types.rb
 - lib/openra/version.rb
 - lib/openra/yaml.rb
-- lib/pascal_string.rb
 - openra.gemspec
 homepage: https://github.com/AMHOL/openra-ruby
 licenses: