feat(gameobj-data.xml): add new jarable type

.github/workflows/rspec_tests.yaml

@@ -31,5 +31,12 @@ jobs:
           version: 1.0
       - name: Run type data migrations to create gameobj-data.xml
         run: bin/migrate
+      - name: Upload gameobj-data.xml artifact
+        uses: actions/upload-artifact@b7c566a772e6b6bfb58ed0dc250532a479d7789f # v6.0.0
+        with:
+          name: gameobj-data-ruby-${{ matrix.ruby }}
+          path: dist/gameobj-data.xml
+          retention-days: 1
+          overwrite: true
       - name: Run RSpec tests
         run: bundle exec rspec

lib/migration.rb

@@ -1 +1 @@
-Dir[File.join(__dir__, "migration", "**", "*.rb")].each do |file| require(file) end
+Dir[File.join(__dir__, "migration", "**", "*.rb")].each do |file| require(file) end

lib/migration/change-set.rb

@@ -1,37 +1,49 @@
-require "pathname"
-
 module Migration
-  class PrettyError < Exception 
+  class PrettyError < StandardError
     def initialize(changeset, msg)
       super <<~ERROR
         \n\t#{changeset.file.split("../").last} >> #{changeset.table.log_name} #{msg}
         ERROR
     end
   end
+
   class KeyError < PrettyError; end
   class RuleError < PrettyError; end
+
   ##
   ## this is execution instance for
   ## evaluating a new set of changes
   ## to be applied to a table
   ##
   class ChangeSet
-    def self.run(table, file, &block)
-      changeset = ChangeSet.new(table, file)
+    def self.run(table, file, tables, &block)
+      changeset = ChangeSet.new(table, file, tables)
       changeset.instance_eval(&block)
       changeset
     end
 
-    attr_reader :table, :file, :inserts, :deletes, :creates
-    def initialize(table, file)
+    attr_reader :table, :file, :inserts, :deletes, :creates, :tables
+
+    def initialize(table, file, tables)
       @table   = table
       @file    = file
+      @tables  = tables # Add this line
       @inserts = {}
       @deletes = {}
       @creates = []
       @table.pending << self
     end
 
+    # Add helper methods
+    def get_table(table_name)
+      @tables[Table.normalize_key(table_name)]
+    end
+
+    def copy_rules_from(source_table_name, key)
+      source_table = get_table(source_table_name)
+      source_table.get_rules(key)
+    end
+
     def will_create?(key)
       @creates.include?(key)
     end

lib/migration/convert.rb

@@ -1,17 +1,17 @@
 module Migration
   module Convert
-    # (?:seasoned |grizzled |battle\-scarred |ancient |veteran )?  
+    # (?:seasoned |grizzled |battle\-scarred |ancient |veteran )?
     def self.maybe_pattern_to_regex(maybes = nil, space: nil, required_match: nil)
       return %{} if maybes.nil?
-      #Migration.log(maybes, label: %i[maybes])
+      # Migration.log(maybes, label: %i[maybes])
       with_whitespace = maybes.map do |maybe|
         if space.eql?(:left)
           " " + maybe
         elsif space.eql?(:right)
-          maybe + " " 
+          maybe + " "
         else
           maybe
-        end 
+        end
       end.join("|")
       if required_match.nil?
         %{(?:#{with_whitespace})?}
@@ -31,4 +31,4 @@ def self.to_safe_xml(str)
       str.gsub(%[&], %[&])
     end
   end
-end
+end

lib/migration/migration.rb

@@ -8,8 +8,9 @@ module Migration
   # creates a raw xml element that does not escape
   # html entities, so regexp can properly be serialized
   def self.raw_element(name, parent = nil)
-    Element.new(name, parent, context = {raw: :all, attribute_quote: :quote})
+    Element.new(name, parent, { raw: :all, attribute_quote: :quote })
   end
+
   ##
   ## lookup from cwd
   ##
@@ -25,19 +26,19 @@ def self.log(msg, label: %i[], color: nil)
   end
 
   def self.load_tables(tables)
-    Hash[tables.map do |table| 
+    Hash[tables.map do |table|
       table = Table.from_yaml(table)
       [table.name, table]
     end]
   end
 
   def self.load_migrations(migrations, tables)
-    migrations.sort.map do |migration| 
-      Migrator.new(migration, tables) 
+    migrations.sort.map do |migration|
+      Migrator.new(migration, tables)
     end
   end
 
-  def self.to_xml(tables)
+  def self.to_xml(_tables)
     root = raw_element(%{data})
     @tables.values.map(&:to_xml).each do |child|
       root.add_element(child)
@@ -51,9 +52,9 @@ def self.run(**opts)
     @migrations = Migration.load_migrations(opts.fetch(:migrations), @tables)
     @migrations.each(&:build).each(&:validate).each(&:apply)
     asset = File.join(opts.fetch(:dist), "gameobj-data.xml")
-    Migration.log(%{writing #{asset}}, 
-      label: :write,
-      color: :pink)
+    Migration.log(%{writing #{asset}},
+                  label: :write,
+                  color: :pink)
     File.open(asset, %{w+}) do |file|
       file.write Migration.to_xml(@tables).to_s
     end

lib/migration/migrator.rb

@@ -1,6 +1,7 @@
 module Migration
-  class TableNotFound < Exception; end
-  class DuplicateTable < Exception; end
+  class TableNotFound < StandardError; end
+  class DuplicateTable < StandardError; end
+
   ##
   ## loads a migration Ruby instance and executes it
   ## within a ChangeSet context, storing the result
@@ -9,12 +10,14 @@ class DuplicateTable < Exception; end
   ##
   class Migrator
     attr_reader :file, :tables, :basename
+
     def initialize(file, tables)
       @file       = file
       @tables     = tables
       @basename   = File.basename(@file)
       @changesets = []
     end
+
     ##
     ## read the file into this binding
     ##
@@ -35,33 +38,37 @@ def apply_creations()
       @changesets.each do |changeset|
         changeset.creates.each do |key|
           Migration.log(%[#{changeset.table.log_name} CREATE key "#{key}"],
-            label: %i[changeset],
-            color: :light_blue)
+                        label: %i[changeset],
+                        color: :light_blue)
           changeset.table.create_key(key)
         end
       end
     end
 
     def apply_insertions()
-      @changesets.each do |changeset| 
+      @changesets.each do |changeset|
         changeset.inserts.each do |key, rules|
           rules.each do |rule|
             Migration.log(%[#{changeset.table.log_name} INSERT #{key} "#{rule}"],
-              label: %i[changeset],
-              color: :green)
+                          label: %i[changeset],
+                          color: :green)
           end
           changeset.table.insert(key, *rules)
         end
       end
     end
 
+    def get_table(table_name)
+      @tables[Table.normalize_key(table_name)]
+    end
+
     def apply_deletions()
-      @changesets.each do |changeset| 
+      @changesets.each do |changeset|
         changeset.deletes.each do |key, rules|
           rules.each do |rule|
             Migration.log(%[#{changeset.table.log_name} DELETE #{key} "#{rule}"],
-              label: %i[changeset],
-              color: :yellow)
+                          label: %i[changeset],
+                          color: :yellow)
           end
 
           changeset.table.delete(key, *rules)
@@ -70,24 +77,24 @@ def apply_deletions()
     end
 
     def assert_table_exists(table_name)
-      table = @tables[Table.normalize_key(table_name)] or
+      @tables[Table.normalize_key(table_name)] or
         fail TableNotFound, Color.red("Table[:#{table_name}] does not exist")
     end
 
     def assert_table_does_not_exist(table_name)
-      table = @tables[Table.normalize_key(table_name)] and
+      @tables[Table.normalize_key(table_name)] and
         fail DuplicateTable, Color.red("Table[:#{table_name}] already exists")
     end
 
     def migrate(*table_names, &migration)
       table_names.each do |table_name|
         table = assert_table_exists(table_name)
-        @changesets << ChangeSet.run(table, @file, &migration)
+        @changesets << ChangeSet.run(table, @file, @tables, &migration) # Add @tables here
       end
       self
     end
 
-    def create_table(table_name, kind: 'type', keys:[])
+    def create_table(table_name, kind: 'type', keys: [])
       assert_table_does_not_exist(table_name)
       normalized_name = Table.normalize_key(table_name)
       @tables[normalized_name] = Table.new(