dgd-tools 0.1.6 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f64aa1b29bc2fb6a0c10292a25246ce4fbe5a43b7fa23dc19a84ab01abc58013
-  data.tar.gz: 60fb058d6f25ca80348e5236450ed3c5fe812137d04e0fce237d36b6b252dfca
+  metadata.gz: 2b3639fa674b53796ffe654f0e7e0deb9506868eece4550b99b4f28b98940e97
+  data.tar.gz: b0f115747b8f790ba079a9789d18e5bbe024de6e9b1c6cc1c476d21066a1b48a
 SHA512:
-  metadata.gz: 30b54b93e1b4e5da44c7cf0bc6e526dd489d74301df20cd4d9644c69aab509416d3082d2646dd6394331f81643a92cbc24933141fdca024057ed6e003866b37a
-  data.tar.gz: 525305f71a39842d01f7ce99f3bce1d85d7dc0e5493411e09759cf003a8632609130281f40ba8ff25bf7edb8ffa73de5e9b53d3c3022c4143a8b99be70a9c4f9
+  metadata.gz: c739260975e503e32a44bfeaf4775d6693e606f35a247f6d432008d0b9e813ac7b29208d1db641dee46be7aec8bbb86e92c1f8fe7e9c7b1c2aadb2ce93e4fb8e
+  data.tar.gz: 50cc3537969a52ca379857a8936b900212e18567bdc10c1cb1152cffb7901f88db53b75a04126b8848e0edb3151d74a4514cc3fe02d7c1ae1f0ece0cbbe7d6f3

data/Gemfile.lock

@@ -1,8 +1,9 @@
 PATH
   remote: .
   specs:
-    dgd-tools (0.1.5)
+    dgd-tools (0.1.7)
       nokogiri (~> 1.10.5)
+      optimist (~> 3.0.1)
 
 GEM
   remote: https://rubygems.org/
@@ -11,6 +12,7 @@ GEM
     minitest (5.14.2)
     nokogiri (1.10.10)
       mini_portile2 (~> 2.4.0)
+    optimist (3.0.1)
     rake (12.3.3)
 
 PLATFORMS

data/README.md

@@ -14,6 +14,18 @@ DGD Manifest is a simple initial library system. I'm sure I'll figure more out a
 
 This work has grown out of [SkotOS and ChatTheatre](https://github.com/ChatTheatre) tasks.
 
+You can find example DGD manifest files under the "test" directory and also in [various](https://github.com/noahgibbs/prototype_vRWOT) [SkotOS-based games](https://github.com/ChatTheatre/gables_game) that use the DGD Manifest system.
+
+You can find example "goods" (library) files under the "goods" subdirectory of this repo.
+
+## WOE Objects and skotos-xml-diff
+
+SkotOS-based games use an XML format for in-game objects called WOE, which is [documented in SkotOS-Doc](https://ChatTheatre.github.io/SkotOS-Doc). The skotos-xml-diff utility will diff between WOE objects or directories of WOE objects.
+
+See SkotOS-Doc for more detail about how this can be used with a SkotOS game.
+
+Run "skotos-xml-diff --help" for a list of options. You can tell it to ignore whitespace, to diff only the Merry (script) contents of the objects, and to ignore certain XML node types.
+
 ## Installation
 
 You would normally install DGDTools directly: `gem install dgd-tools`.
@@ -26,6 +38,8 @@ If you have a DGD application that uses DGD Manifest, run `dgd-manifest install`
 
 That fully-assembled DGD directory is named ".root". To run your dgd server, type "dgd-manifest server".
 
+If you update files in your root and want to update files under the generated root directory, use "dgd-manifest update".
+
 ## Using DGD Manifest with your DGD Application
 
 Your app will need a dgd.manifest file, which is a lot like NPM's package.json file.

data/dgd-tools.gemspec

@@ -25,4 +25,5 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency "nokogiri", "~>1.10.5"
+  spec.add_runtime_dependency "optimist", "~>3.0.1"
 end

data/exe/dgd-manifest

@@ -51,6 +51,17 @@ when "install"
     repo.precheck(current_dir)
     repo.assemble_app(current_dir)
     puts "Assembled DGD application into #{current_dir}"
+when "update"
+    unless File.exist?("dgd.manifest")
+        raise "I don't see a dgd.manifest file in this directory!"
+    end
+    puts "Running DGD Manifest installer..."
+    repo = DGD::Manifest::Repo.new
+    repo.manifest_file("dgd.manifest")
+    current_dir = File.expand_path(".")
+    repo.precheck(current_dir)
+    repo.update_app(current_dir)
+    puts "Updated DGD application in #{current_dir}"
 when "server"
     puts "Starting DGD server..."
     DGD::Manifest.system_call("~/.dgd-tools/dgd/bin/dgd dgd.config")

data/exe/skotos-xml-diff

@@ -4,28 +4,27 @@
 # SkotOS-or-similar game to find out what updates should
 # be merged between them.
 
+require 'optimist'
 require "dgd-tools/skotos_xml_obj"
 
-if ARGV.size == 1 && ["-h", "--help"].include?(ARGV[0])
-    print <<HELP_INFO
-skotos-xml-diff [file1] [file2]
-
-OR
-
-skotos-xml-diff [dir1] [dir2]
-HELP_INFO
-    exit
+OPTS = Optimist::options do
+    version "DGD-tools version #{DGD::VERSION}"
+    banner <<BANNER
+Usage:
+    skotos-xml-diff [options] <file_or_dir_1> <file_or_dir_2>
+where [options] are:
+BANNER
+    opt :merry_only, "Only diff Merry scripts"
+    opt :ignore_whitespace, "Ignore whitespace in final diff"
+    opt :ignore_types, "Comma-separated list of XML node types to ignore (e.g. Combat:Base,Base:Exit)", type: :string
 end
 
-if ARGV.size != 2
-    STDERR.puts "Usage: skotos-xml-diff <obj_or_dir_1> <obj_or_dir_2>"
-    exit -1
-end
+Optimist::die "Supply exactly two files or directories -- you supplied #{ARGV.size}!" unless ARGV.size == 2
+Optimist::die "Supply both files or both directories, not one of each!" if File.directory?(ARGV[0]) ^ File.directory?(ARGV[1])
 
-if File.directory?(ARGV[0]) ^ File.directory?(ARGV[1])
-    STDERR.puts "Please give two files or two directories, not one of each!"
-    exit -1
-end
+SkotOS::XMLObject.merry_only = true if OPTS[:merry_only]
+SkotOS::XMLObject.ignore_whitespace = true if OPTS[:ignore_whitespace]
+SkotOS::XMLObject.ignore_types = OPTS[:ignore_types].split(",") if OPTS[:ignore_types]
 
 if File.directory?(ARGV[0])
     diff = SkotOS::XMLObject.diff_dirs(*ARGV)

data/goods/chattheatre_kernellib.goods

@@ -0,0 +1,12 @@
+{
+    "name": "ChatTheatre Kernellib",
+    "git": {
+        "url": "https://github.com/ChatTheatre/kernellib.git",
+        "branch": "master"
+    },
+    "paths": {
+    	"src/include/kernel": "include/kernel",
+    	"src/include/*.h": "include",
+    	"src/kernel": "kernel"
+    }
+}

data/lib/dgd-tools/manifest.rb

@@ -16,7 +16,6 @@ module DGD::Manifest
     }
     KERNEL_PATHS = KERNEL_PATH_MAP.values
     DEFAULT_KERNELLIB_URL = "https://github.com/ChatTheatre/kernellib"
-
     GENERATED_ROOT = ".root"
 
     def self.system_call(cmd)
@@ -78,12 +77,12 @@ module DGD::Manifest
             raise("No manifest file!") if @no_manifest_file
 
             @manifest_file.specs.each do |spec|
-                git_repo = spec.source
-                git_repo.use_details(spec.source_details)  # This sets things like checked-out branch
+                spec_git_repo = spec.source
+                spec_git_repo.use_details(spec.source_details)  # This sets things like checked-out branch
 
                 spec.paths.each do |from, to|
-                    # Note: git_repo.local_dir is an absolute path.
-                    from_path = "#{git_repo.local_dir}/#{from}"
+                    # Note: spec_git_repo.local_dir is an absolute path.
+                    from_path = "#{spec_git_repo.local_dir}/#{from}"
                     if File.directory?(from_path)
                         files = Dir["#{from_path}/**/*"].to_a + Dir["#{from_path}/**/.*"].to_a
                         dirs = files.select { |file| File.directory?(file) }
@@ -95,13 +94,13 @@ module DGD::Manifest
                         no_wild_from_path = components[0..(first_wild_idx-1)].join("/")
                         wild_path = components[first_wild_idx..-1].join("/")
 
-                        files = Dir["#{git_repo.local_dir}/#{no_wild_from_path}/#{wild_path}"].to_a
+                        files = Dir["#{spec_git_repo.local_dir}/#{no_wild_from_path}/#{wild_path}"].to_a
                         dirs = files.select { |file| File.directory?(file) }
                         dirs += files.map { |f| File.dirname(f) }
                         dirs.uniq!
 
                         non_dirs = files - dirs
-                        operations << { cmd: "cp", from: "#{git_repo.local_dir}/#{no_wild_from_path}", to: to, dirs: dirs, non_dirs: non_dirs, comment: :path_wildcard }
+                        operations << { cmd: "cp", from: "#{spec_git_repo.local_dir}/#{no_wild_from_path}", to: to, dirs: dirs, non_dirs: non_dirs, comment: :path_wildcard }
                     else
                         # A single file
                         operations << { cmd: "cp", from: from_path, to: to, dirs: [], non_dirs: [from_path], comment: :single_file }
@@ -122,16 +121,29 @@ module DGD::Manifest
 
         public
 
+        def dgd_root(location)
+            "#{File.expand_path(location)}/#{GENERATED_ROOT}"
+        end
+
         def assemble_app(location)
-            dgd_root = "#{File.expand_path(location)}/#{GENERATED_ROOT}"
-            FileUtils.rm_rf(dgd_root)
+            Dir[File.join(dgd_root(location), "*")].each { |dir| FileUtils.rm_rf dir }
+
+            write_app_files(location)
+        end
+
+        def update_app(location)
+            write_app_files(location)  # TODO: maybe check files dates? Some way to do update-only
+        end
 
+        protected
+
+        def write_app_files(location)
             Dir.chdir(location) do
                 write_config_file("#{location}/dgd.config")
                 FileUtils.mkdir_p("#{location}/state") # Statedir for statedumps, editor files, etc.
 
                 assembly_operations(location).each do |sd_hash|
-                    to_path = "#{dgd_root}/#{sd_hash[:to]}"
+                    to_path = "#{dgd_root(location)}/#{sd_hash[:to]}"
 
                     # Make appropriate dirs, including empty ones
                     sd_hash[:dirs].each do |dir|
@@ -140,7 +152,7 @@ module DGD::Manifest
 
                     # Copy all files
                     sd_hash[:non_dirs].each do |from_file|
-                        to_file = from_file.sub(sd_hash[:from], "#{dgd_root}/#{sd_hash[:to]}")
+                        to_file = from_file.sub(sd_hash[:from], "#{dgd_root(location)}/#{sd_hash[:to]}")
                         to_dir = File.dirname(to_file)
                         FileUtils.mkdir_p to_dir
                         FileUtils.cp from_file, to_file
@@ -149,6 +161,8 @@ module DGD::Manifest
             end
         end
 
+        public
+
         def precheck(location)
             all_files = assembly_operations(location).flat_map { |sd| sd[:non_dirs] }
 
@@ -160,40 +174,7 @@ module DGD::Manifest
 
         def write_config_file(path)
             File.open(path, "wb") do |f|
-                f.write <<CONTENTS
-/* These are SkotOS limits. They are larger than you are likely to need. They should
-   be configurable but they are not yet. */
-telnet_port = ([
-    "*":50100  /* telnet port number */
-]);
-binary_port = ([
-    "*":50110 /* Failsafe */
-]);   /* binary ports */
-directory = "./#{GENERATED_ROOT}";
-
-users       = 100;           /* max # of users */
-editors     = 40;           /* max # of editor sessions */
-ed_tmpfile  = "../state/ed";        /* proto editor tmpfile */
-swap_file   = "../state/swap";  /* swap file */
-swap_size   = 1048576;         /* # sectors in swap file */
-sector_size = 512;          /* swap sector size */
-swap_fragment   = 4096;           /* fragment to swap out */
-static_chunk    = 64512;        /* static memory chunk */
-dynamic_chunk   = 261120;       /* dynamic memory chunk */
-dump_file   = "../state/dump";  /* dump file */
-dump_interval   = 3600;             /* dump interval */
-
-typechecking    = 2;            /* highest level of typechecking */
-include_file    = "/include/std.h";     /* standard include file */
-include_dirs    = ({ "/include", "~/include" }); /* directories to search */
-auto_object     = "/kernel/lib/auto";   /* auto inherited object */
-driver_object   = "/kernel/sys/driver"; /* driver object */
-create      = "_F_create";      /* name of create function */
-
-array_size  = 16384;         /* max array size */
-objects     = 262144;          /* max # of objects */
-call_outs   = 16384;          /* max # of call_outs */
-CONTENTS
+                f.write @manifest_file.dgd_config.as_file
             end
         end
     end
@@ -226,11 +207,11 @@ CONTENTS
         def use_details(details)
             if details["branch"]
                 Dir.chdir(@local_dir) do
-                    DGD::Manifest.system_call("git checkout #{details["branch"]}")
+                    DGD::Manifest.system_call("git checkout #{details["branch"]} && git pull")
                 end
             else
                 Dir.chdir(@local_dir) do
-                    DGD::Manifest.system_call("git checkout #{default_branch}")
+                    DGD::Manifest.system_call("git checkout #{default_branch} && git pull")
                 end
             end
         end
@@ -240,7 +221,7 @@ CONTENTS
         attr_reader :path
         attr_reader :repo
         attr_reader :specs
-        attr_reader :app_root
+        attr_reader :dgd_config
 
         def initialize(repo, path)
             @path = path
@@ -250,8 +231,6 @@ CONTENTS
 
             read_manifest_file(contents)
 
-            @app_root = contents["app_root"] || "app"
-
             output_paths = @specs.flat_map { |s| s.paths.values }
             unless output_paths == output_paths.uniq
                 repeated_paths = output_paths.select { |p| output_paths.count(p) > 1 }
@@ -267,9 +246,9 @@ CONTENTS
             #else
             #    puts "This dgd.manifest needs the default Kernel Library."
             #    # This app has specified no kernellib paths -- add them
-            #    git_repo = @repo.git_repo(DEFAULT_KERNELLIB_URL)
+            #    spec_git_repo = @repo.git_repo(DEFAULT_KERNELLIB_URL)
             #    klib_spec = GoodsSpec.new @repo, name: "default Kernel Library",
-            #        source: git_repo, paths: KERNEL_PATH_MAP
+            #        source: spec_git_repo, paths: KERNEL_PATH_MAP
             #    specs.unshift klib_spec
             #end
 
@@ -298,6 +277,8 @@ CONTENTS
 
             @specs = []
 
+            @dgd_config = DGDRuntimeConfig.new (contents["config"] || {})
+
             if contents["unbundled_goods"]
                 raise "Unbundled_goods must be an array!" unless contents["unbundled_goods"].is_a?(Array)
 
@@ -319,9 +300,15 @@ CONTENTS
             end
         end
 
+        def app_root
+            @dgd_config.app_root
+        end
+
         def unbundled_json_to_spec(fields)
             source = nil
             source_details = nil
+            dependencies = []
+
             if fields["git"]
                 raise "A git source requires a git url: #{fields.inspect}!" unless fields["git"]["url"]
                 source = @repo.git_repo(fields["git"]["url"])
@@ -334,7 +321,23 @@ CONTENTS
                 raise "Paths in Goods files must map strings to strings! #{fields["paths"].inspect}"
             end
 
-            spec = GoodsSpec.new(@repo, name: fields["name"], source: source, source_details: source_details, paths: fields["paths"])
+            if fields["dependencies"]
+                # For now, permit a single string as a dependency.
+                fields["dependencies"] = [ fields["dependencies"] ] if fields["dependencies"].is_a?(String)
+
+                fields["dependencies"].each do |dep|
+                    if dep.is_a?(String)
+                        dependencies.push "url" => dep
+                    elsif dep.is_a?(Hash)
+                        raise "Currently only URL-based dependencies on Goods files are supported!" unless dep["url"]
+                        dependencies.push dep
+                    else
+                        raise "Unexpected dependency type #{dep.class} when parsing DGD Manifest specs, item: #{dep.inspect}"
+                    end
+                end
+            end
+
+            spec = GoodsSpec.new(@repo, name: fields["name"], source: source, source_details: source_details, paths: fields["paths"], dependencies: dependencies)
             return spec
         end
     end
@@ -345,8 +348,9 @@ CONTENTS
         attr_reader :source
         attr_reader :source_details
         attr_reader :paths
+        attr_reader :dependencies
 
-        def initialize(repo, name:, source:, source_details: {}, paths:)
+        def initialize(repo, name:, source:, source_details: {}, paths:, dependencies:)
             @repo = repo
             @name = name
             @source = source
@@ -359,6 +363,7 @@ CONTENTS
             end
 
             @paths = cleaned_paths
+            @dependencies = dependencies
         end
     end
 
@@ -455,4 +460,114 @@ FILE_CONTENTS
             puts "Successfully created project at #{@location}."
         end
     end
+
+    class DGDRuntimeConfig
+        attr_reader :app_root
+
+        DEFAULT_CONFIG = {
+                users: 100,
+                editors: 40,
+                swap_size: 1048576,
+                sector_size: 512,
+                swap_fragment: 4096,
+                static_chunk: 64512,
+                dynamic_chunk: 261120,
+                dump_interval: 3600,
+                typechecking: 2,
+                include_file: "/include/std.h",
+                include_dirs: ["/include", "~/include"],
+                auto_object: "/kernel/lib/auto",
+                driver_object: "/kernel/sys/driver",
+                create: "_F_create",
+                array_size: 16384,
+                objects: 262144,
+                call_outs: 16384,
+            }
+        CONFIG_KEYS = DEFAULT_CONFIG.keys.map(&:to_s) + [ "app_root", "ports", "telnet_ports", "dump_file", "statedir" ]
+
+        def initialize(config_data)
+            @app_root = config_data["app_root"] || "app"
+            @ports = {
+                "*" => 50100,
+            }
+            @telnet_ports = {
+                "*" => 50110,
+            }
+            @statedir = config_data["statedir"] || "state"
+            @dump_file = if config_data["dump_file"]
+                    "../" + config_data["dump_file"]
+                else
+                    "../#{@statedir}/dump"
+                end
+            @config = DEFAULT_CONFIG.dup
+
+            @raw_data = config_data
+            @config.keys.each do |prop|
+                # For now, assume and require that JSON data is the correct type if present
+                @config[prop] = config_data[prop.to_s] if config_data[prop.to_s]
+            end
+            unexpected_config_keys = config_data.keys - CONFIG_KEYS
+            unless unexpected_config_keys.empty?
+                raise "Unexpected key names in DGD configuration: #{unexpected_config_keys.inspect}!"
+            end
+
+            if config_data["telnet_ports"]
+                @telnet_ports = config_to_ports(config_data["telnet_ports"])
+            end
+            if config_data["ports"]
+                @ports = config_to_ports(config_data["ports"])
+            end
+        end
+
+        def config_to_ports(data)
+            if data.is_a?(Hash)
+                # TODO: verify that keys are IP addr strings and values are legal port numbers
+                return data
+            elsif data.is_a?(Array)
+                # TODO: verify that data is an array of legal integer port numbers
+                ports = {}
+                data.each { |p| ports["*"] = p }
+                return ports
+            elsif data.is_a?(Integer)
+                return { "*": data }
+            else
+                raise "dgd-manifest: not sure how to get port data from a #{data.class.name} -- #{data.inspect}!"
+            end
+        end
+
+        def as_file
+            return <<DGD_CONFIG
+telnet_port = ([
+    #{@telnet_ports.map { |ip, p| "#{ip.inspect}:#{p}" }.join(",\n    ") }
+]);   /* legacy telnet ports */
+binary_port = ([
+    #{@ports.map { |ip, p| "#{ip.inspect}:#{p}" }.join(",\n    ") }
+]);   /* binary ports */
+directory       = "./#{GENERATED_ROOT}";
+
+users           = #{@config[:users]}; /* max # of connections */
+editors         = #{@config[:editors]}; /* max # of built-in-editor sessions */
+ed_tmpfile      = "../#{@statedir}/ed"; /* proto editor tmpfile */
+swap_file       = "../#{@statedir}/swap"; /* swap file */
+swap_size       = #{@config[:swap_size]}; /* # sectors in swap file */
+sector_size     = #{@config[:sector_size]}; /* swap sector size */
+swap_fragment   = #{@config[:swap_fragment]}; /* fragment to swap out */
+static_chunk    = #{@config[:static_chunk]}; /* static memory chunk */
+dynamic_chunk   = #{@config[:dynamic_chunk]}; /* dynamic memory chunk */
+dump_file       = #{@dump_file.inspect}; /* dump file */
+dump_interval   = #{@config[:dump_interval]}; /* expected statedump interval in seconds */
+
+typechecking    = #{@config[:typechecking]}; /* level of typechecking (2 is highest) */
+include_file    = #{@config[:include_file].inspect}; /* standard include file */
+include_dirs    = ({ #{@config[:include_dirs].map(&:inspect).join(", ")} }); /* directories to search */
+auto_object     = #{@config[:auto_object].inspect}; /* auto inherited object */
+driver_object   = #{@config[:driver_object].inspect}; /* driver object */
+create          = #{@config[:create].inspect}; /* name of create function */
+
+array_size      = #{@config[:array_size]}; /* max array size */
+objects         = #{@config[:objects]}; /* max # of objects */
+call_outs       = #{@config[:call_outs]}; /* max # of callouts */
+DGD_CONFIG
+        end
+    end
 end

data/lib/dgd-tools/skotos_xml_obj.rb

@@ -8,13 +8,21 @@ require "tempfile"
 
 module SkotOS; end
 
-# TODO: remove <Core:Property property="revisions"> from anywhere in the XML tree
+class SkotOS::XMLObject; end
+
+class << SkotOS::XMLObject
+    attr_accessor :merry_only
+    attr_accessor :ignore_whitespace
+    attr_accessor :ignore_types
+end
 
 class SkotOS::XMLObject
     attr_reader :pretty
+    attr_reader :noko_doc
 
-    def initialize(pretty)
+    def initialize(pretty, noko_doc: nil)
         @pretty = pretty
+        @noko_doc = noko_doc
     end
 
     def self.from_file(filename)
@@ -25,9 +33,7 @@ class SkotOS::XMLObject
         remove_undiffed(doc)
 
         pretty = doc.to_xml(indent:3)
-        #data = doc.to_hash
-        #prune_whitespace(data)
-        SkotOS::XMLObject.new pretty
+        SkotOS::XMLObject.new pretty, noko_doc: doc
     end
 
     def self.diff_between(obj1, obj2, o1_name: "Object 1", o2_name: "Object 2")
@@ -40,8 +46,11 @@ class SkotOS::XMLObject
             of1.close
             of2.close
 
+            diff_opts = [ "-c" ]
+            diff_opts += [ "-w", "-B" ] if self.ignore_whitespace
+
             # Diff 'fails' if there's a difference between the two files.
-            diff = system_call("diff -c #{of1.path} #{of2.path}", fail_ok: true)
+            diff = system_call("diff #{diff_opts.join(" ")} #{of1.path} #{of2.path}", fail_ok: true)
             diff.sub!(of1.path, o1_name)
             diff.sub!(of2.path, o2_name)
         ensure
@@ -51,28 +60,35 @@ class SkotOS::XMLObject
         diff
     end
 
-    def self.skip_ignored_files(list)
-        list.select do |path|
-            !path[/,v$/] &&  # Ignore files ending in comma-v
-                !path[/-backup-\d+-\d+-\d+\.xml/]  # Ignore files ending in -backup-[DATE].xml
+    def self.skip_ignored_files(list, base_dir)
+        if self.merry_only
+            list.select { |path| File.directory?(base_dir + "/" + path) ||
+                path[/.xml$/] || path[/.XML$/] }
+        else
+            list.select do |path|
+                !path[/,v$/] &&  # Ignore files ending in comma-v
+                    !path[/-backup-\d+-\d+-\d+\.xml/] && # Ignore files ending in -backup-[DATE].xml
+                    path != ".git" && # Ignore .git directories
+                    path != "MOVED" # Ignore MOVED - it's a sort of recycle, waiting to be emptied
+            end
         end
     end
 
     def self.diff_dirs(dir1, dir2)
-        entries1 = skip_ignored_files(Dir.glob("*", base: dir1).to_a)
-        entries2 = skip_ignored_files(Dir.glob("*", base: dir2).to_a)
+        entries1 = skip_ignored_files(Dir.glob("*", base: dir1).to_a, dir1)
+        entries2 = skip_ignored_files(Dir.glob("*", base: dir2).to_a, dir2)
 
         only_in_1 = entries1 - entries2
         only_in_2 = entries2 - entries1
         in_both = entries1 & entries2
 
         diff = []
-        diff << "Only in first: #{only_in_1.join(", ")}" unless only_in_1.empty?
-        diff << "Only in second: #{only_in_2.join(", ")}" unless only_in_2.empty?
+        diff << "Only in first: #{only_in_1.map { |s| dir1 + "/" + s }.join(", ")}" unless only_in_1.empty?
+        diff << "Only in second: #{only_in_2.map { |s| dir2 + "/" + s }.join(", ")}" unless only_in_2.empty?
 
         in_both.each do |file|
-            in_1 = "#{dir1}/#{file}"
-            in_2 = "#{dir2}/#{file}"
+            in_1 = File.join dir1, file
+            in_2 = File.join dir2, file
             if File.directory?(in_1) ^ File.directory?(in_2)
                 diff << "Only a directory in one, not both: #{dir1}/#{file}"
             elsif File.directory?(in_1)
@@ -97,6 +113,90 @@ class SkotOS::XMLObject
                 end
             end
         end
+
+        rev = noko_single_node(doc.root, "Core:Property", attrs: { "property" => "revisions" })
+        rev.remove if rev
+
+        list = noko_single_node(doc.root, "Core:Property", attrs: { "property" => "#list#" })
+        list.remove if list
+
+        if self.merry_only
+            # Kill off all the non-Merry nodes
+            noko_remove_non_merry_nodes(doc.root)
+        end
+
+        if self.ignore_types
+            self.ignore_types.each do |ignored_type|
+                skipped = noko_with_name_and_attrs(doc.root, ignored_type)
+                skipped.each { |n| n.remove }
+            end
+        end
+
+        base_combat = noko_single_node(doc.root, "Base:Combat")
+        if base_combat
+            base_strength = noko_single_node(base_combat, "Base:Strength", attrs: { "value" => "1" })
+            base_max_fatigue = noko_single_node(base_combat, "Base:MaxFatigue", attrs: { "value" => "1" })
+            if base_strength && base_max_fatigue && noko_non_text(base_combat.children).size == 2
+                next_text = base_combat.next
+                base_combat.remove
+                next_text.remove
+            end
+        end
+    end
+
+    def self.noko_single_node(node, name, attrs: {})
+        choices = noko_with_name_and_attrs(node, name, attrs)
+        if choices.size < 1
+            nil
+        elsif choices.size > 1
+            raise "Single-node search returned more than one node! #{name.inspect}, #{attrs.inspect}"
+        else
+            choices[0]
+        end
+    end
+
+    def self.noko_non_text(nodes)
+        nodes.select { |n| !n.is_a? Nokogiri::XML::Text }
+    end
+
+    def self.noko_with_name_and_attrs(node, name, attrs = {})
+        results = node.children.flat_map { |n| noko_with_name_and_attrs(n, name, attrs) }
+        if node.name == name &&
+            attrs.all? { |k, v| node.attribute(k).value == v }
+            results << node
+        end
+        results
+    end
+
+    def self.noko_remove_non_merry_nodes(root)
+        root.children.each do |node|
+            if node.name != "Core:PropertyContainer"
+                node.remove
+                next
+            end
+
+            node.children.each do |node2|
+                if node2.name != "Core:PCProperties"
+                    node2.remove
+                    next
+                end
+
+                node2.children.each do |property_node|
+                    if property_node.name != "Core:Property" || property_node.attribute("property").value[0..5] != "merry:"
+                        property_node.remove
+                        next
+                    end
+                    # Leave the Merry node alone
+                end
+
+                if node2.children.size == 0
+                    node2.remove
+                end
+            end
+            if node.children.size == 0
+                node.remove
+            end
+        end
     end
 
     def self.system_call(cmd, fail_ok: false)

data/lib/dgd-tools/version.rb

@@ -1,3 +1,3 @@
 module DGD
-  VERSION = "0.1.6"
+  VERSION = "0.1.7"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dgd-tools
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Noah Gibbs
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-02-04 00:00:00.000000000 Z
+date: 2021-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.10.5
+- !ruby/object:Gem::Dependency
+  name: optimist
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.1
 description: dgd-tools supplies DGD Manifest and eventually perhaps other tools. DGD
   Manifest is an experimental DGD library and packaging system.
 email:
@@ -53,6 +67,7 @@ files:
 - example_xml/t2/Thing.xml
 - exe/dgd-manifest
 - exe/skotos-xml-diff
+- goods/chattheatre_kernellib.goods
 - goods/skotos_httpd.goods
 - lib/dgd-tools/manifest.rb
 - lib/dgd-tools/skotos_xml_obj.rb