dgd-tools 0.1.5 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7248b5e9b0f257568633b8f83c166430e1451da62c0d84acfa468f48a6bf4196
-  data.tar.gz: 435dfa244ae63087b45acd18f9220267cf4facf560f2c1a235392d6ec9fe00f6
+  metadata.gz: df6b6f5495201cda1059723bc87848c81ef6d112449fd147aed1a6c08873b13f
+  data.tar.gz: f5adb6e0b687e71002c25fdf694375b06b1c3e400a6a5adaa0f759ae502abea8
 SHA512:
-  metadata.gz: 0f6534cced478794994f6a85ebf10277d6c0455d095708a49901b3527bea1534a9d18b2c5dc6bffc5b3a03bf5949fd352644b019148f541f1e6f98660aee060b
-  data.tar.gz: 86c72de588f15ce2f1804068771e46a6ca71f707399fc807b74bdca02c52ef173dab11058eb24475e387852443de79c59cd553d9902a79611240a39f1ae72431
+  metadata.gz: 91624cda3d356f2dc5d17e7a003a1ef21bf989c94ef5761e6c265d0fffc08fac932a59dd4e1da9f824e6f9cf79d9746eb9a33bff44a87d7693f9b34476852ecd
+  data.tar.gz: 2a3efbd628524723b1f7e15982dea8077088fd305a68cfd186a0a0396ac3f321c117e6d1301398b9b80c922524f479a4b6b97c8736b3116d9d7f7793f8fa38b1

data/.gitignore

@@ -7,3 +7,5 @@
 /spec/reports/
 /tmp/
 *.gem
+test/data/**/dgd.config
+test/data/*/.root

data/Gemfile.lock

@@ -1,8 +1,9 @@
 PATH
   remote: .
   specs:
-    dgd-tools (0.1.4)
+    dgd-tools (0.1.10)
       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

@@ -1,48 +1,82 @@
 #!/usr/bin/env ruby
 
+require "optimist"
 require "dgd-tools/manifest"
 
-if ARGV.size == 0
-    ARGV.push "install"
-end
+SUB_COMMANDS = %w(new test install update server)
+
+OPTS = Optimist::options do
+    version "DGD-tools version #{DGD::VERSION}"
+    banner <<BANNER
+Use dgd.manifest to assemble your DGD application.
+
+Available subcommands:
+  new [project_name]: create a new DGD-manifest project
+  test: make sure the dgd.manifest file is well-formed and usable
+  install: compile the DGD application to a config file and a root directory
+  update: copy files into generated root directory but do *not* clear 'extra' files (e.g. user data)
+  server: run DGD with the generated root and configuration
 
-if ARGV == ["--version"]
-    puts "dgd-tools version #{DGD::VERSION}"
-    exit
+Available options:
+BANNER
+    opt :verbose, "Print verbose output where available"
+    stop_on SUB_COMMANDS
 end
 
-case ARGV[0]
-when "new"
-    unless ARGV.size == 2
-        puts "Usage: dgd-manifest new [project name]"
-        raise "Must supply exactly one argument to dgd-manifest new!"
-    end
-    appdir = DGD::Manifest::AppDirectory.new(File.expand_path ARGV[1])
-    appdir.name = ARGV[1]
-    appdir.create!
-when "test"
-    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")
-    repo.precheck(".")
-    puts "Verified Manifest packages: this looks likely correct."
-when "install"
-    unless File.exist?("dgd.manifest")
-        raise "I don't see a dgd.manifest file in this directory!"
+ARGV.push("install") if ARGV.size == 0
+cmd = ARGV.shift
+cmd_opts = case cmd
+    when "test"
+        #Optimist::options do
+        #  opt :harsh, "check as exactly as possible"
+        #end
+
+        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")
+        repo.precheck(".", verbose: OPTS[:verbose])
+        puts "Verified Manifest packages: this looks likely correct."
+
+    when "install"
+        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, verbose: OPTS[:verbose])
+        repo.assemble_app(current_dir, verbose: OPTS[:verbose])
+        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, verbose: OPTS[:verbose])
+        repo.update_app(current_dir, verbose: OPTS[:verbose])
+        puts "Updated DGD application in #{current_dir}"
+
+    when "server"
+        puts "Starting DGD server..."
+        DGD::Manifest.system_call("~/.dgd-tools/dgd/bin/dgd dgd.config")
+
+    when "new"
+        unless ARGV.size == 1
+            puts "Usage: dgd-manifest new [project name]"
+            Optimist::die "Must supply exactly one argument to dgd-manifest new!"
+        end
+        appdir = DGD::Manifest::AppDirectory.new(File.expand_path ARGV[0])
+        appdir.name = ARGV[0]
+        appdir.create!
+
+    else
+        Optimist::die "Unknown subcommand: #{cmd.inspect}"
     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.assemble_app(current_dir)
-    puts "Assembled DGD application into #{current_dir}"
-when "server"
-    puts "Starting DGD server..."
-    DGD::Manifest.system_call("~/.dgd-tools/dgd/bin/dgd dgd.config")
-else
-    raise "Unrecognised #{$0} command: #{ARGV[0].inspect}!"
-end

data/exe/skotos-xml-diff

@@ -4,17 +4,28 @@
 # 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 != 2
-    STDERR.puts "Usage: skotos-xml-diff <obj_or_dir_1> <obj_or_dir_2>"
-    exit -1
+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 :version, "Print DGD version and exit"
+    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 File.directory?(ARGV[0]) ^ File.directory?(ARGV[1])
-    STDERR.puts "Please give two files or two directories, not one of each!"
-    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])
+
+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,38 +16,39 @@ 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)
         puts "Running command: #{cmd.inspect}..."
         system(cmd, out: $stdout, err: :out)
         unless $?.success?
-            raise "Error running command: #{cmd.inspect}!"
+            raise "Error running command in #{Dir.pwd}: #{cmd.inspect}!"
         end
     end
 
     # This is a repo of everything DGD Manifest saves between runs.
     # It includes downloaded Git repos, Goods files and more.
     class Repo
-        attr_reader :manifest_dir
+        attr_reader :shared_dir
 
         def initialize
+            @no_manifest_file = true
             @home = ENV["HOME"]
-            @manifest_dir = "#{@home}/.dgd-tools"
-            Dir.mkdir(@manifest_dir) unless File.directory?(@manifest_dir)
+            @shared_dir = "#{@home}/.dgd-tools"
+            Dir.mkdir(@shared_dir) unless File.directory?(@shared_dir)
+
             ["git", "goods"].each do |subdir|
-                full_subdir = "#{@manifest_dir}/#{subdir}"
+                full_subdir = "#{@shared_dir}/#{subdir}"
                 Dir.mkdir(full_subdir) unless File.directory?(full_subdir)
             end
 
-            unless File.exist?("#{@manifest_dir}/dgd/bin/dgd")
-                dgd_dir = "#{@manifest_dir}/dgd"
+            unless File.exist?("#{@shared_dir}/dgd/bin/dgd")
+                dgd_dir = "#{@shared_dir}/dgd"
                 if File.directory?(dgd_dir)
                     # Not clear to me what to do here...
                 else
                     DGD::Manifest.system_call("git clone https://github.com/ChatTheatre/dgd.git #{dgd_dir}")
-                    Dir.chdir("#{@manifest_dir}/dgd/src") do
+                    Dir.chdir("#{@shared_dir}/dgd/src") do
                         DGD::Manifest.system_call(DGD_BUILD_COMMAND)
                     end
                 end
@@ -60,82 +61,120 @@ module DGD::Manifest
         end
 
         def manifest_file(path)
-            raise "Already have a dgd.manifest file!" if @manifest_file
+            raise "Already have a dgd.manifest file!" unless @no_manifest_file
 
-            @manifest_file ||= AppFile.new(self, path)
+            @no_manifest_file = false
+            @manifest_file ||= AppFile.new(self, path, shared_dir: shared_dir)
         end
 
-        def files_to_assemble
-            subdirs = []
+        protected
+
+        # This includes files to assemble... But also subdirectories and commands. This format is
+        # unstable and ugly, and should not be exposed to outside parties who might later depend on it.
+        def assembly_operations(location, verbose:)
+            operations = []
 
-            @manifest_file.specs.each do |spec|
-                git_repo = spec.source
-                git_repo.use_details(spec.source_details)
+            raise("No manifest file!") if @no_manifest_file
+
+            # For each spec, put its dependencies before itself in order
+            @manifest_file.ordered_specs.each do |spec|
+                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|
-                    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) }
                         non_dirs = files - dirs
-                        subdirs << { from: from_path, to: to, dirs: dirs, non_dirs: non_dirs, source: git_repo }
+                        operations << { cmd: "cp", from: from_path, to: to, dirs: dirs, non_dirs: non_dirs, comment: :single_dir }
                     elsif from_path["*"]  # If from_path contains at least one asterisk
                         components = from.split("/")
                         first_wild_idx = components.index { |item| item["*"] }
                         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
-                        subdirs << { from: "#{git_repo.local_dir}/#{no_wild_from_path}", to: to, dirs: dirs, non_dirs: non_dirs, source: git_repo }
+                        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
-                        subdirs << { from: from_path, to: to, dirs: [], non_dirs: [from], source: git_repo }
+                        operations << { cmd: "cp", from: from_path, to: to, dirs: [], non_dirs: [from_path], comment: :single_file }
                     end
                 end
             end
 
-            subdirs
+            app_path = "#{File.expand_path(location)}/#{@manifest_file.app_root}"
+            app_files = Dir["#{app_path}/**/*"].to_a
+            app_dirs = app_files.select { |f| File.directory?(f) }
+            app_non_dirs = app_files - app_dirs
+            unless app_dirs.empty? && app_non_dirs.empty?
+                operations << { cmd: "cp", from: app_path, to: ".", dirs: app_dirs, non_dirs: app_non_dirs, comment: :app_files }  # No source
+            end
+
+            operations
         end
 
-        def assemble_app(location)
-            dgd_root = "#{File.expand_path(location)}/#{GENERATED_ROOT}"
-            app_path = "#{File.expand_path(location)}/#{@manifest_file.app_root}"
-            FileUtils.rm_rf(dgd_root)
-            FileUtils.cp_r(app_path, dgd_root)
+        public
+
+        def dgd_root(location)
+            "#{File.expand_path(location)}/#{GENERATED_ROOT}"
+        end
 
-            write_config_file("#{location}/dgd.config")
-            FileUtils.mkdir_p("#{location}/state") # Statedir for statedumps, editor files, etc.
+        def assemble_app(location, verbose:)
+            Dir[File.join(dgd_root(location), "*")].each { |dir| FileUtils.rm_rf dir }
 
-            files_to_assemble.sort_by { |sd| sd[:to] }.each do |sd_hash|
-                to_path = "#{dgd_root}/#{sd_hash[:to]}"
+            write_app_files(location, verbose: verbose)
+        end
 
-                # Make appropriate dirs, including empty ones
-                sd_hash[:dirs].each do |dir|
-                    FileUtils.mkdir_p dir.sub(sd_hash[:from], to_path)
-                end
+        def update_app(location, verbose:)
+            write_app_files(location, verbose: verbose)
+        end
+
+        protected
+
+        def write_app_files(location, verbose:)
+            Dir.chdir(location) do
+                write_config_file("#{location}/dgd.config")
+                FileUtils.mkdir_p("#{location}/state") # Statedir for statedumps, editor files, etc.
+
+                assembly_operations(location, verbose: verbose).each do |sd_hash|
+                    to_path = "#{dgd_root(location)}/#{sd_hash[:to]}"
+
+                    if verbose
+                        puts "  Copy #{sd_hash[:from]} -> #{sd_hash[:to]}, files #{sd_hash[:non_dirs].join(", ")}"
+                    end
 
-                # 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_dir = File.dirname(to_file)
-                    FileUtils.mkdir_p to_dir
-                    FileUtils.cp from_file, to_file
+                    # Make appropriate dirs, including empty ones
+                    sd_hash[:dirs].each do |dir|
+                        FileUtils.mkdir_p dir.sub(sd_hash[:from], to_path)
+                    end
+
+                    # Copy all files
+                    sd_hash[:non_dirs].each do |from_file|
+                        to_file = from_file.sub(sd_hash[:from], "#{dgd_root(location)}/#{sd_hash[:to]}")
+                        to_dir = File.dirname(to_file)
+                        begin
+                            FileUtils.mkdir_p to_dir
+                            FileUtils.cp from_file, to_file
+                        rescue
+                            puts "Error when copying: #{from_file} -> #{to_file} in #{sd_hash.inspect}"
+                            raise
+                        end
+                    end
                 end
             end
         end
 
-        def precheck(location)
-            app_path = "#{File.expand_path(location)}/#{@manifest_file.app_root}"
-            app_files = Dir["#{app_path}/**"].to_a.select { |f| !File.directory?(f) }
+        public
 
-            subdirs = files_to_assemble
-            all_files = subdirs.flat_map { |sd| sd[:non_dirs] } + app_files
-            all_files.sort!
+        def precheck(location, verbose:)
+            all_files = assembly_operations(location, verbose: verbose).flat_map { |sd| sd[:non_dirs] }
 
             if all_files.size != all_files.uniq.size
                 repeated = all_files.uniq.select { |f| all_files.count(f) > 1 }
@@ -145,40 +184,7 @@ module DGD::Manifest
 
         def write_config_file(path)
             File.open(path, "wb") do |f|
-                f.write <<CONTENTS
-/* These are SkotOS limits. They are enormous. 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
@@ -192,8 +198,8 @@ CONTENTS
         def initialize(repo, git_url)
             @git_url = git_url
             @repo = repo
-            local_path = git_url.tr("/\\", "_")
-            @local_dir = "#{@repo.manifest_dir}/git/#{local_path}"
+            local_path = git_url.tr("/\\ ", "_")
+            @local_dir = "#{@repo.shared_dir}/git/#{local_path}"
 
             if File.directory?(@local_dir)
                 Dir.chdir(@local_dir) do
@@ -205,40 +211,39 @@ CONTENTS
         end
 
         def default_branch
-            return @default_branch if @default_branch
-            output = `git rev-parse --abbrev-ref origin/HEAD`.chomp
-            @default_branch = output.gsub(/^origin\//, "")
+            @default_branch ||= `git rev-parse --abbrev-ref origin/HEAD`.chomp.gsub(/^origin\//, "")
         end
 
         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
     end
 
+    # This class parses the DGD manifest
     class AppFile
         attr_reader :path
         attr_reader :repo
         attr_reader :specs
-        attr_reader :app_root
+        attr_reader :dgd_config
+        attr_reader :shared_dir
 
-        def initialize(repo, path)
+        def initialize(repo, path, shared_dir:)
             @path = path
             @repo = repo
+            @shared_dir = shared_dir
             raise("No such dgd.manifest file as #{path.inspect}!") unless File.exist?(path)
             contents = AppFile.parse_manifest_file(path)
 
             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 }
@@ -254,9 +259,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
 
@@ -285,6 +290,12 @@ CONTENTS
 
             @specs = []
 
+            @dgd_config = DGDRuntimeConfig.new (contents["config"] || {})
+
+            if contents["app_root"]
+                raise "App_root must now be inside config block!"
+            end
+
             if contents["unbundled_goods"]
                 raise "Unbundled_goods must be an array!" unless contents["unbundled_goods"].is_a?(Array)
 
@@ -296,7 +307,10 @@ CONTENTS
 
                 @specs += contents["goods"].map do |goods_url|
                     begin
-                        json_contents = JSON.parse(URI.open(goods_url).read)
+                        text_contents = URI.open(goods_url).read
+                        local_path = shared_dir + "/goods/" + goods_url.tr("/\\ ", "_")
+                        File.open(local_path, "wb") { |f| f.write(text_contents) }
+                        json_contents = JSON.parse text_contents
                     rescue
                         STDERR.puts "Error reading or parsing by URL: #{goods_url.inspect}"
                         raise
@@ -306,9 +320,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"])
@@ -321,9 +341,46 @@ 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)
+
+                goods_url = nil
+                fields["dependencies"].each do |dep|
+                    if dep.is_a?(String)
+                        goods_url = dep
+                    elsif dep.is_a?(Hash)
+                        raise "Currently only URL-based dependencies on Goods files are supported!" unless dep["url"]
+                        goods_url = dep["url"]
+                    else
+                        raise "Unexpected dependency type #{dep.class} when parsing DGD Manifest specs, item: #{dep.inspect}"
+                    end
+
+                    text_contents = URI.open(goods_url).read
+                    local_path = shared_dir + "/goods/" + goods_url.tr("/\\ ", "_")
+                    File.open(local_path, "wb") { |f| f.write(text_contents) }
+                    dep_fields = JSON.parse text_contents
+
+                    dependencies.push unbundled_json_to_spec(dep_fields)
+                end
+            end
+
+            spec = GoodsSpec.new(@repo, name: fields["name"], source: source, source_details: source_details, paths: fields["paths"], dependencies: dependencies)
             return spec
         end
+
+        def ordered_specs
+            @specs.flat_map do |s|
+                deps = [s]
+                deps_to_add = s.dependencies
+                while(deps_to_add.size > 0)
+                    next_deps = deps_to_add.flat_map { |dep| dep.dependencies }
+                    deps = deps_to_add + deps
+                    deps_to_add = next_deps
+                end
+                deps
+            end
+        end
     end
 
     class GoodsSpec
@@ -332,8 +389,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
@@ -346,6 +404,7 @@ CONTENTS
             end
 
             @paths = cleaned_paths
+            @dependencies = dependencies
         end
     end
 
@@ -382,7 +441,7 @@ CONTENTS
     "app_root": "app",
     "goods": [
         "# This is an example goods file - substitute your own.",
-        "https://raw.githubusercontent.com/noahgibbs/dgd-tools/main/goods/skotos_httpd.goods"
+        "https://raw.githubusercontent.com/ChatTheatre/dgd-tools/main/goods/skotos_httpd.goods"
     ],
     "unbundled_goods": [
         {
@@ -442,4 +501,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,13 @@ class SkotOS::XMLObject
             of1.close
             of2.close
 
+            diff_opts = [ "c" ]
+            diff_opts += [ "b", "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)
+            cmd = "diff -#{diff_opts.join("")} #{of1.path} #{of2.path}"
+            #puts "Diff command: #{cmd}"
+            diff = system_call(cmd, fail_ok: true)
             diff.sub!(of1.path, o1_name)
             diff.sub!(of2.path, o2_name)
         ensure
@@ -51,28 +62,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 +115,101 @@ class SkotOS::XMLObject
                 end
             end
         end
+
+        rev = noko_single_node(doc.root, "Core:Property", attrs: { "property" => "revisions" })
+        noko_remove(rev) if rev
+
+        list = noko_single_node(doc.root, "Core:Property", attrs: { "property" => "#list#" })
+        list.remove if list
+
+        properties = noko_with_name_and_attrs(doc.root, "Core:Property")
+        properties.each do |prop_node|
+            prop_node.remove if prop_node.attribute("property").value.start_with?("sys:sync")
+        end
+
+        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| noko_remove(n) }
+            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_remove(node)
+        nn = node.next
+        nn.remove if nn.is_a?(Nokogiri::XML::Text)
+        node.remove
+    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.5"
+  VERSION = "0.1.10"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dgd-tools
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.10
 platform: ruby
 authors:
 - Noah Gibbs
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-21 00:00:00.000000000 Z
+date: 2021-03-18 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