dgd-tools 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2637c36239c1aabf37dbac03f0404cab8bb2ea493753bebc2710d44e03f78e11
+  data.tar.gz: f544c13905cceb2c080385edc9122a4b89905700ac8195b97410ae58d829e5b6
+SHA512:
+  metadata.gz: ce3e707b25251764367464866d71c64ece85e69cb8c39d2589d3342f263f9ba3c98270d3f130c05b481fac04d0c06e613d9992b87ab54bf99851e3fcd98ebc58
+  data.tar.gz: 41acb15b29ca4667590ca59cace0a5563f1129845d205c32dbe662f6222aad9c174a09548e98f0e0b450c63b3e073cb5baa614eddbe390ab9e4084f1a8ca9e7d

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.gem

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.7.0
+before_install: gem install bundler -v 2.1.2

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in dgd-tools.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "minitest", "~> 5.0"

data/Gemfile.lock

@@ -0,0 +1,21 @@
+PATH
+  remote: .
+  specs:
+    dgd-tools (0.1.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.14.2)
+    rake (12.3.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  dgd-tools!
+  minitest (~> 5.0)
+  rake (~> 12.0)
+
+BUNDLED WITH
+   2.1.2

data/README.md

@@ -0,0 +1,95 @@
+# DGD Tools
+
+DGD Tools is a repository of Ruby tools designed to make the DGD interpreter easier to use. DGD started as an interpreter for a dialect of LPC, the C-like language of LPMuds. It has drifted over the years into a powerful general-purpose dynamic language.
+
+DGD Tools requires Ruby. It comes preinstalled on recent Mac computers, or you can install it yourself on Linux. On Windows, if you're not using WSL or similar, you're going to have a less-than-optimal experience.
+
+## DGD Manifest
+
+DGD Manifest is an experimental library system for [DGD](https://github.com/dworkin/LPC). I don't actually know of a second attempt to set up a library system for it. DGD Manifest is inspired loosely by RubyGems and the Ruby [Bundler](https://bundler.io).
+
+DGD Manifest refers to its libraries as Goods. The file dgd.manifest, if it's present in your application's directory, specifies where and how to find its various libraries. By running "dgd-manifest install", you can install those various files into a complete application.
+
+DGD Manifest is a simple initial library system. I'm sure I'll figure more out as I go along, and I'm sure it'll need changes. But you have to start somewhere!
+
+This work has grown out of [SkotOS and ChatTheatre](https://github.com/ChatTheatre) tasks.
+
+## Installation
+
+You would normally install DGDTools directly: `gem install dgd-tools`.
+
+It's possible to add it to a Ruby's application's Gemfile. Ordinarily you wouldn't.
+
+## Usage
+
+If you have a DGD application that uses DGD Manifest, run `dgd-manifest install` to download its dependencies and create a fully-assembled DGD directory for it. You can also `dgd-manifest test` to make sure its dependencies are downloaded and satisfied without building an application directory.
+
+That fully-assembled DGD directory is named ".root". To run your dgd server, type "dgd-manifest server".
+
+## 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.
+
+Here's an example:
+
+```
+{
+    "name": "eOS",
+    "version": "1.0.0",
+    "description": "A game platform from the folks at ChatTheatre",
+    "app_root": "root",
+    "goods": [
+        "https://raw.githubusercontent.com/noahgibbs/dgd-tools/main/goods/skotos_httpd.goods"
+    ],
+    "unbundled_goods": [
+        {
+            "name": "kernellib",
+            "git": {
+                "url": "https://github.com/dworkin/cloud-server.git",
+                "branch": "master"
+            },
+            "paths": {
+                "src/doc/kernel": "doc/kernel",
+                "src/include/kernel": "include/kernel",
+                "src/kernel": "kernel"
+            }
+        }
+    ]
+}
+```
+
+DGD Manifest needs a .goods file for each of your dependencies - or it needs the equivalent of that .goods file, in the form of unbundled_goods. That one line in "goods" is basically the same information in unbundled_goods, just stored at a URL that DGD Manifest can download for you.
+
+A Manifest-enabled DGD codebase can provide Goods files directly and you can use them by their URLs. A non-Manifest codebase may require you to create your own .goods files, or use them directly and unbundled in the dgd.manifest file for your app.
+
+## Creating the Goods
+
+To create a new Manifest-usable library, you'll want to create a Goods file for it.
+
+Here's what those look like:
+
+```
+{
+    "name": "SkotOS HTTPD",
+    "git": {
+        "url": "https://github.com/ChatTheatre/SkotOS.git"
+    },
+    "paths": {
+        "skoot/usr/HTTP": "usr/HTTP"
+    }
+}
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/noahgibbs/dgd-tools.
+
+## License
+
+The gem is available as open source under the terms of the AGPL.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "dgd-tools/manifest"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/dgd-tools.gemspec

@@ -0,0 +1,26 @@
+require_relative 'lib/dgd-tools/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dgd-tools"
+  spec.version       = DGD::VERSION
+  spec.authors       = ["Noah Gibbs"]
+  spec.email         = ["the.codefolio.guy@gmail.com"]
+
+  spec.summary       = %q{dgd-tools supplies DGD tools -- like the DGD Manifest library system -- via a Ruby gem.}
+  spec.description   = %q{dgd-tools supplies DGD Manifest and eventually perhaps other tools. DGD Manifest is an experimental DGD library and packaging system.}
+  spec.homepage      = "https://github.com/noahgibbs/dgd-tools"
+  spec.license       = "AGPL"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end

data/exe/dgd-manifest

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+require "dgd-tools/manifest"
+
+if ARGV.size == 0
+    ARGV.push "install"
+end
+
+case ARGV[0]
+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")
+    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")
+    repo.assemble_app(".")
+when "server"
+    puts "Starting DGD server... (not yet)"
+else
+    raise "Unrecognised #{$0} command: #{ARGV[0].inspect}!"
+end

data/goods/skotos_httpd.goods

@@ -0,0 +1,10 @@
+{
+    "name": "SkotOS HTTPD",
+    "git": {
+        "url": "https://github.com/ChatTheatre/SkotOS.git",
+        "branch": "master"
+    },
+    "paths": {
+        "skoot/usr/HTTP": "usr/HTTP"
+    }
+}

data/lib/dgd-tools/manifest.rb

@@ -0,0 +1,276 @@
+require "dgd-tools/version"
+
+require "json"
+require "open-uri"
+require "fileutils"
+
+module DGD; end
+
+module DGD::Manifest
+    DGD_BUILD_COMMAND = %(make DEFINES='-DUINDEX_TYPE="unsigned int" -DUINDEX_MAX=UINT_MAX -DEINDEX_TYPE="unsigned short" -DEINDEX_MAX=USHRT_MAX -DSSIZET_TYPE="unsigned int" -DSSIZET_MAX=1048576' install
+)
+    KERNEL_PATHS = ["include/kernel", "kernel"]
+    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}!"
+        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
+
+        def initialize
+            @home = ENV["HOME"]
+            @manifest_dir = "#{@home}/.dgd-tools"
+            Dir.mkdir(@manifest_dir) unless File.directory?(@manifest_dir)
+            ["git", "goods"].each do |subdir|
+                full_subdir = "#{@manifest_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"
+                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
+                        DGD::Manifest.system_call(DGD_BUILD_COMMAND)
+                    end
+                end
+            end
+        end
+
+        def git_repo(git_url)
+            @git_repos ||= {}
+            @git_repos[git_url] ||= GitRepo.new(self, git_url)
+        end
+
+        def manifest_file(path)
+            raise "Already have a dgd.manifest file!" if @manifest_file
+
+            @manifest_file ||= AppFile.new(self, path)
+        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)
+
+            write_config_file("#{location}/dgd.config")
+            specs = @manifest_file.specs
+
+            specs.each do |spec|
+                git_repo = spec.source
+                git_repo.use_details(spec.source_details)
+
+                spec.paths.each do |from, to|
+                    from_path = "#{git_repo.local_dir}/#{from}"
+                    to_path = "#{dgd_root}/#{to}"
+                    to_dir = to_path.split("/")[0..-2].join("/")
+                    FileUtils.mkdir_p to_dir
+                    STDERR.puts "COPYING #{from_path.inspect} #{to_path.inspect}"
+                    FileUtils.cp_r(from_path, to_path)
+                end
+            end
+        end
+
+        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
+            end
+        end
+    end
+
+    # This is a Git repo managed by dgd-tools.
+    # It can be a source for a GoodsSpec
+    class GitRepo
+        attr_reader :local_dir
+        attr_reader :git_url
+
+        def initialize(repo, git_url)
+            @git_url = git_url
+            @repo = repo
+            local_path = git_url.tr("/\\", "_")
+            @local_dir = "#{@repo.manifest_dir}/git/#{local_path}"
+
+            if File.directory?(@local_dir)
+                Dir.chdir(@local_dir) do
+                    DGD::Manifest.system_call("git checkout #{default_branch} && git pull")
+                end
+            else
+                DGD::Manifest.system_call("git clone #{@git_url} #{@local_dir}")
+            end
+        end
+
+        def default_branch
+            return @default_branch if @default_branch
+            output = `git rev-parse --abbrev-ref origin/HEAD`.chomp
+            @default_branch = output.gsub(/^origin\//, "")
+        end
+
+        def use_details(details)
+            if details["branch"]
+                Dir.chdir(@local_dir) do
+                    DGD::Manifest.system_call("git checkout #{details["branch"]}")
+                end
+            else
+                Dir.chdir(@local_dir) do
+                    DGD::Manifest.system_call("git checkout #{default_branch}")
+                end
+            end
+        end
+    end
+
+    class AppFile
+        attr_reader :path
+        attr_reader :repo
+        attr_reader :specs
+        attr_reader :app_root
+
+        def initialize(repo, path)
+            @path = path
+            @repo = repo
+            raise("No such dgd.manifest file as #{path.inspect}!") unless File.exist?(path)
+            contents = JSON.load(File.read(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 }
+                raise "Repeated (conflicting?) paths in dgd.manifest! #{repeated_paths.inspect}"
+            end
+
+            # Make sure the dgd.manifest file overrides either no kernel paths or both/all
+            if KERNEL_PATHS.any? { |kp| output_paths.include?(kp) }
+                unless KERNEL_PATHS.all? { |kp| output_paths.include?(kp) }
+                    raise "dgd.manifest file #{path.inspect} includes some Kernel Library paths but not all! All needed: #{KERNEL_PATHS}!"
+                end
+                puts "This dgd.manifest file overrides the Kernel Library with its own."
+            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)
+                kl_paths = { "src/kernel" => "/kernel", "src/include/kernel" => "/include/kernel", "src/doc/kernel" => "/doc/kernel" }
+                klib_spec = GoodsSpec.new @repo, name: "default Kernel Library",
+                    source: git_repo, paths: kl_paths
+                specs.push klib_spec
+            end
+
+            nil
+        end
+
+        def read_manifest_file(contents)
+            raise "Expected a top-level JSON object in dgd.manifest!" unless contents.is_a?(Hash)
+
+            @specs = []
+
+            if contents["unbundled_goods"]
+                raise "Unbundled_goods must be an array!" unless contents["unbundled_goods"].is_a?(Array)
+
+                @specs += contents["unbundled_goods"].map { |item| unbundled_json_to_spec(item) }
+            end
+
+            if contents["goods"]
+                raise "Goods must be an array!" unless contents["goods"].is_a?(Array)
+
+                @specs += contents["goods"].map do |goods_url|
+                    begin
+                        json_contents = JSON.parse(URI.open(goods_url).read)
+                    rescue
+                        STDERR.puts "Error reading or parsing by URL: #{goods_url.inspect}"
+                        raise
+                    end
+                    unbundled_json_to_spec(json_contents)
+                end
+            end
+        end
+
+        def unbundled_json_to_spec(fields)
+            source = nil
+            source_details = nil
+            if fields["git"]
+                raise "A git source requires a git url: #{fields.inspect}!" unless fields["git"]["url"]
+                source = @repo.git_repo(fields["git"]["url"])
+                source_details = fields["git"]  # May contain branch info, etc.
+            else
+                raise "DGD Manifest currently requires a Git-based source!"
+            end
+
+            unless fields["paths"].all? { |k, v| k.is_a?(String) && v.is_a?(String) }
+                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"])
+            return spec
+        end
+    end
+
+    class GoodsSpec
+        attr_reader :repo
+        attr_reader :name
+        attr_reader :source
+        attr_reader :source_details
+        attr_reader :paths
+
+        def initialize(repo, name:, source:, source_details: {}, paths:)
+            @repo = repo
+            @name = name
+            @source = source
+            @source_details = source_details
+
+            cleaned_paths = {}
+            paths.each do |k, v|
+                # Remove leading and trailing slashes
+                cleaned_paths[k.gsub(/^\//, "").chomp("/")] = v.gsub(/^\//, "").chomp("/")
+            end
+
+            @paths = cleaned_paths
+        end
+    end
+end

data/lib/dgd-tools/version.rb

@@ -0,0 +1,3 @@
+module DGD
+  VERSION = "0.1.1"
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: dgd-tools
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Noah Gibbs
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2020-10-23 00:00:00.000000000 Z
+dependencies: []
+description: dgd-tools supplies DGD Manifest and eventually perhaps other tools. DGD
+  Manifest is an experimental DGD library and packaging system.
+email:
+- the.codefolio.guy@gmail.com
+executables:
+- dgd-manifest
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- dgd-tools.gemspec
+- exe/dgd-manifest
+- goods/skotos_httpd.goods
+- lib/dgd-tools/manifest.rb
+- lib/dgd-tools/version.rb
+homepage: https://github.com/noahgibbs/dgd-tools
+licenses:
+- AGPL
+metadata:
+  homepage_uri: https://github.com/noahgibbs/dgd-tools
+  source_code_uri: https://github.com/noahgibbs/dgd-tools
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key:
+specification_version: 4
+summary: dgd-tools supplies DGD tools -- like the DGD Manifest library system -- via
+  a Ruby gem.
+test_files: []