dgd-tools 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b3639fa674b53796ffe654f0e7e0deb9506868eece4550b99b4f28b98940e97
-  data.tar.gz: b0f115747b8f790ba079a9789d18e5bbe024de6e9b1c6cc1c476d21066a1b48a
+  metadata.gz: d608eb777e5e4e39c2d9e08175876de2b7a47f8fc20b775692165d8c46dcd3cd
+  data.tar.gz: c4a833c253ac5c8c191f5d288ae30b3bcb4301371940e524ccd34ce219163f3a
 SHA512:
-  metadata.gz: c739260975e503e32a44bfeaf4775d6693e606f35a247f6d432008d0b9e813ac7b29208d1db641dee46be7aec8bbb86e92c1f8fe7e9c7b1c2aadb2ce93e4fb8e
-  data.tar.gz: 50cc3537969a52ca379857a8936b900212e18567bdc10c1cb1152cffb7901f88db53b75a04126b8848e0edb3151d74a4514cc3fe02d7c1ae1f0ece0cbbe7d6f3
+  metadata.gz: c107d368ef11e8742dcb024194bfb1b13ff916d1572589a0adee3ca263618e56eaed34f407f611e175e0332a7591d4ed1d0de6b2fa624c714c4680669ac84769
+  data.tar.gz: 66adf5b5c678361e47ae5dac4d706cabeec768de2b50ff021cb101e2ec008d6fa18a39f567e3617272250240c9c9bab32da50d423397d8ab9064ef2fb6d4f448

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dgd-tools (0.1.7)
+    dgd-tools (0.1.8)
       nokogiri (~> 1.10.5)
       optimist (~> 3.0.1)
 

data/exe/dgd-manifest

@@ -1,70 +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)
 
-if ARGV == ["--version"]
-    puts "dgd-tools version #{DGD::VERSION}"
-    exit
-end
+OPTS = Optimist::options do
+    version "DGD-tools version #{DGD::VERSION}"
+    banner <<BANNER
+Use dgd.manifest to assemble your DGD application.
 
-if ARGV.size == 1 && ["-h", "--help"].include?(ARGV[0])
-    puts <<HELP_INFO
-dgd-manifest commands:
+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
 
-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
-HELP_INFO
-    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!"
-    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 "update"
-    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: 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)
+        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.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")
-else
-    raise "Unrecognised #{$0} command: #{ARGV[0].inspect}!"
-end

data/exe/skotos-xml-diff

@@ -14,6 +14,7 @@ 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

data/lib/dgd-tools/manifest.rb

@@ -22,7 +22,7 @@ module DGD::Manifest
         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
 
@@ -64,19 +64,20 @@ module DGD::Manifest
             raise "Already have a dgd.manifest file!" unless @no_manifest_file
 
             @no_manifest_file = false
-            @manifest_file ||= AppFile.new(self, path)
+            @manifest_file ||= AppFile.new(self, path, shared_dir: shared_dir)
         end
 
         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)
+        def assembly_operations(location, verbose:)
             operations = []
 
             raise("No manifest file!") if @no_manifest_file
 
-            @manifest_file.specs.each do |spec|
+            # 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
 
@@ -125,26 +126,30 @@ module DGD::Manifest
             "#{File.expand_path(location)}/#{GENERATED_ROOT}"
         end
 
-        def assemble_app(location)
+        def assemble_app(location, verbose:)
             Dir[File.join(dgd_root(location), "*")].each { |dir| FileUtils.rm_rf dir }
 
-            write_app_files(location)
+            write_app_files(location, verbose: verbose)
         end
 
-        def update_app(location)
-            write_app_files(location)  # TODO: maybe check files dates? Some way to do update-only
+        def update_app(location, verbose:)
+            write_app_files(location, verbose: verbose)
         end
 
         protected
 
-        def write_app_files(location)
+        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).each do |sd_hash|
+                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
+
                     # Make appropriate dirs, including empty ones
                     sd_hash[:dirs].each do |dir|
                         FileUtils.mkdir_p dir.sub(sd_hash[:from], to_path)
@@ -154,8 +159,13 @@ module DGD::Manifest
                     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)
-                        FileUtils.mkdir_p to_dir
-                        FileUtils.cp from_file, 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
@@ -163,8 +173,8 @@ module DGD::Manifest
 
         public
 
-        def precheck(location)
-            all_files = assembly_operations(location).flat_map { |sd| sd[:non_dirs] }
+        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 }
@@ -188,7 +198,7 @@ module DGD::Manifest
         def initialize(repo, git_url)
             @git_url = git_url
             @repo = repo
-            local_path = git_url.tr("/\\", "_")
+            local_path = git_url.tr("/\\ ", "_")
             @local_dir = "#{@repo.shared_dir}/git/#{local_path}"
 
             if File.directory?(@local_dir)
@@ -217,15 +227,18 @@ module DGD::Manifest
         end
     end
 
+    # This class parses the DGD manifest
     class AppFile
         attr_reader :path
         attr_reader :repo
         attr_reader :specs
         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)
 
@@ -279,6 +292,10 @@ module DGD::Manifest
 
             @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)
 
@@ -290,7 +307,10 @@ module DGD::Manifest
 
                 @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
@@ -325,21 +345,42 @@ module DGD::Manifest
                 # 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)
-                        dependencies.push "url" => dep
+                        goods_url = dep
                     elsif dep.is_a?(Hash)
                         raise "Currently only URL-based dependencies on Goods files are supported!" unless dep["url"]
-                        dependencies.push dep
+                        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
@@ -400,7 +441,7 @@ module DGD::Manifest
     "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": [
         {

data/lib/dgd-tools/skotos_xml_obj.rb

@@ -46,11 +46,13 @@ class SkotOS::XMLObject
             of1.close
             of2.close
 
-            diff_opts = [ "-c" ]
-            diff_opts += [ "-w", "-B" ] if self.ignore_whitespace
+            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 #{diff_opts.join(" ")} #{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
@@ -115,11 +117,16 @@ class SkotOS::XMLObject
         end
 
         rev = noko_single_node(doc.root, "Core:Property", attrs: { "property" => "revisions" })
-        rev.remove if rev
+        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)
@@ -128,7 +135,7 @@ class SkotOS::XMLObject
         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 }
+                skipped.each { |n| noko_remove(n) }
             end
         end
 
@@ -144,6 +151,12 @@ class SkotOS::XMLObject
         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

data/lib/dgd-tools/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dgd-tools
 version: !ruby/object:Gem::Version
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors:
 - Noah Gibbs
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-03-03 00:00:00.000000000 Z
+date: 2021-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri