dr_talon 0.1.0

data/lib/dr_talon/templates/talon/generate/component_tests.rb.tt

@@ -0,0 +1,15 @@
+require "<%= talon_require %>"
+require "<%= file_require %>"
+
+class <%= class_name %>Tests
+  class TestScene < Talon::Scene; end
+
+  def test_<%= file_name %>_updates_and_draws(args, assert)
+    scene = TestScene.new
+    scene.args = args
+    go = scene.spawn(:subject) { |g| g.add(<%= class_name %>) }
+    scene.tick
+
+    assert.true! go[<%= class_name %>].is_a?(<%= class_name %>), "the component should be attached"
+  end
+end

data/lib/dr_talon/templates/talon/generate/prefab.rb.tt

@@ -0,0 +1,11 @@
+# A prefab: a reusable game object setup. Spawn one with
+#   spawn(:<%= file_name %>, <%= class_name %>, x: 640, y: 360)
+module <%= class_name %>
+  # @param go [Talon::GameObject] the object being spawned
+  def self.call(go)
+    go.w ||= 32
+    go.h ||= 32
+    go.path ||= "sprites/square/blue.png"
+    # go.add(SomeComponent, speed: 2)
+  end
+end

data/lib/dr_talon/templates/talon/generate/prefab_tests.rb.tt

@@ -0,0 +1,15 @@
+require "<%= talon_require %>"
+require "<%= file_require %>"
+
+class <%= class_name %>Tests
+  class TestScene < Talon::Scene; end
+
+  def test_<%= file_name %>_spawns(args, assert)
+    scene = TestScene.new
+    scene.args = args
+    go = scene.spawn(:<%= file_name %>, <%= class_name %>, x: 10, y: 20)
+    scene.tick
+
+    assert.equal! [ go.x, go.y ], [ 10, 20 ]
+  end
+end

data/lib/dr_talon/templates/talon/generate/scene.rb.tt

@@ -0,0 +1,14 @@
+# A scene: one screen or level of the game. Switch to it with
+#   game.change_scene(<%= class_name %>.new)
+class <%= class_name %> < Talon::Scene
+  # Scene state lives in args.state and is cleared when the scene ends.
+  # state :score, default: 0
+
+  on_enter do
+    # Spawn the scene's game objects, e.g.:
+    # spawn(:player, Player, x: 640, y: 360)
+  end
+
+  on_exit do
+  end
+end

data/lib/dr_talon/templates/talon/generate/scene_tests.rb.tt

@@ -0,0 +1,13 @@
+require "<%= talon_require %>"
+require "<%= file_require %>"
+
+class <%= class_name %>Tests
+  def test_<%= file_name %>_is_entered_by_the_game(args, assert)
+    scene = <%= class_name %>.new
+    game = Talon::Game.new(scene)
+    game.args = args
+    game.tick
+
+    assert.equal! scene.game, game
+  end
+end

data/lib/dr_talon/test_report.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module DrTalon
+  # The outcome of one +dragonruby --test FILE+ run, read from its output.
+  # DragonRuby exits 0 whether tests pass, fail or the file doesn't load, so
+  # the output is the only signal.
+  #
+  # @!attribute [r] status
+  #   @return [Symbol] +:passed+, +:failed+, +:error+ (an exception outside a
+  #     test, such as a syntax error), +:no_tests+ or +:timeout+
+  # @!attribute [r] passed
+  #   @return [Integer]
+  # @!attribute [r] failed
+  #   @return [Integer]
+  # @!attribute [r] inconclusive
+  #   @return [Integer] tests that made no assertions
+  # @!attribute [r] details
+  #   @return [String] failure or exception details, empty when passing
+  # @!attribute [r] output
+  #   @return [String] everything DragonRuby printed
+  TestReport = Data.define(:status, :passed, :failed, :inconclusive, :details, :output)
+
+  class TestReport
+    SUMMARY = /\] (\d+) test\(s\) (passed|failed|inconclusive)\./
+    EXCEPTION = /^(?:- \[Game\] )?\* (?:EXCEPTION|ERROR):/
+    NO_TESTS = "No tests were found"
+    ENGINE_LINE = /^[-*?] \[Engine\]/
+
+    # @param output [String]
+    # @return [TestReport]
+    def self.parse(output)
+      counts = Hash.new(0)
+      output.scan(SUMMARY) { |count, kind| counts[kind] = count.to_i }
+      summary = output.match?(SUMMARY)
+      lines = output.lines(chomp: true)
+
+      status, details =
+        if (start = lines.index { |line| line.match?(EXCEPTION) })
+          [:error, section(lines, start)]
+        elsif !summary && output.include?(NO_TESTS)
+          [:no_tests, ""]
+        elsif !summary
+          [:error, "DragonRuby didn't print a test summary."]
+        elsif counts["failed"].positive?
+          [:failed, section(lines, lines.index { |line| line.match?(/\] \d+ test\(s\) failed\./) } + 1)]
+        else
+          [:passed, ""]
+        end
+
+      new(status: status, passed: counts["passed"], failed: counts["failed"],
+        inconclusive: counts["inconclusive"], details: details, output: output)
+    end
+
+    # @param output [String] whatever was printed before the run was stopped
+    # @return [TestReport]
+    def self.timeout(output)
+      new(status: :timeout, passed: 0, failed: 0, inconclusive: 0, details: "", output: output)
+    end
+
+    # @return [Boolean]
+    def passed?
+      status == :passed
+    end
+
+    # Lines from +start+ up to DragonRuby's shutdown messages, without the
+    # "- [Game] " log prefixes and with runs of blank lines collapsed.
+    def self.section(lines, start)
+      finish = ((start + 1)...lines.size).find { |i| lines[i].match?(ENGINE_LINE) } || lines.size
+      lines[start...finish]
+        .map { |line| line.sub(/\A- \[Game\] /, "").rstrip }
+        .chunk_while { |a, b| a.empty? && b.empty? }.map(&:first)
+        .join("\n").strip
+    end
+    private_class_method :section
+  end
+end

data/lib/dr_talon/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DrTalon
+  VERSION = "0.1.0"
+end

data/lib/dr_talon.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "dr_talon/version"
+require_relative "dr_talon/errors"
+require_relative "dr_talon/paths"
+require_relative "dr_talon/config"
+require_relative "dr_talon/file_copy"
+require_relative "dr_talon/http"
+require_relative "dr_talon/credentials"
+require_relative "dr_talon/engine"
+require_relative "dr_talon/project"
+require_relative "dr_talon/doctor"
+require_relative "dr_talon/test_report"
+require_relative "dr_talon/runner"
+require_relative "dr_talon/deps"
+require_relative "dr_talon/talon_framework"
+require_relative "dr_talon/cli"

data/sig/dr_talon.rbs

@@ -0,0 +1,524 @@
+module DrTalon
+  VERSION: String
+
+  class Error < StandardError
+  end
+
+  class Paths
+    APP_NAME: String
+
+    def initialize: (?env: Hash[String, String], ?host_os: String, ?home: String) -> void
+    def data_dir: () -> String
+    def cache_dir: () -> String
+    def config_dir: () -> String
+    def engines_dir: () -> String
+    def downloads_dir: () -> String
+    def config_file: () -> String
+    def credentials_file: () -> String
+  end
+
+  class Config < Data
+    DEFAULTS: Hash[Symbol, String?]
+
+    attr_reader default_template: String
+    attr_reader dev_id: String?
+    attr_reader dev_title: String?
+
+    def self.load: (?String path) -> Config
+  end
+
+  class HTTP
+    MAX_REDIRECTS: Integer
+
+    class Error < DrTalon::Error
+    end
+
+    class Unauthorized < Error
+    end
+
+    class Auth < Data
+      attr_reader username: String
+      attr_reader password: String
+    end
+
+    def get: (String url, ?auth: Auth?) -> String
+    def post_form: (String url, Hash[String, String] form) -> String
+    def download: (String url, String path, ?auth: Auth?) ?{ (Integer received, Integer? total) -> void } -> String
+  end
+
+  class Credentials < Data
+    ENV_USERNAME: String
+    ENV_PASSWORD: String
+
+    class InsecureFile < Error
+    end
+
+    attr_reader username: String
+    attr_reader password: String
+    attr_reader source: (:env | :file | :prompt)
+
+    def self.lookup: (?env: Hash[String, String], ?path: String) -> Credentials?
+    def self.from_env: (?Hash[String, String] env) -> Credentials?
+    def self.load: (String path) -> Credentials?
+    def self.delete: (String path) -> bool
+    def save: (String path) -> void
+    def to_auth: () -> HTTP::Auth
+  end
+
+  module FileCopy
+    FICLONE: Integer
+    CLONE_UNSUPPORTED: Array[Class]
+
+    def self.copy: (String src, String dst) -> bool
+    def self.try_clone: (IO input, IO output) -> bool
+  end
+
+  class Project
+    PIN_FILE: String
+
+    class NotFound < Error
+    end
+
+    def self.find: (?String dir) -> Project?
+    def self.locate: (?String dir) -> Project
+
+    attr_reader root: String
+
+    def initialize: (String root) -> void
+    def layout: () -> (:full | :game_only | nil)
+    def game_dir: () -> String
+    def pin_path: () -> String
+    def pin: () -> Engine::Spec?
+    def pin!: (Engine::Installation installation) -> void
+    def path: (*String relative) -> String
+  end
+
+  class Doctor
+    METADATA_PLACEHOLDERS: Hash[String, String]
+
+    def self.unset_metadata: (Project project) -> Array[String]?
+
+    class Check < Data
+      attr_reader status: (:ok | :warning | :error)
+      attr_reader message: String
+    end
+
+    def initialize: (Project project, Engine::Store store, ?host_platform: String) -> void
+    def checks: () -> Array[Check]
+  end
+
+  module Engine
+    TIERS: Array[String]
+
+    class InvalidEngine < Error
+    end
+
+    class NotFound < Error
+    end
+
+    class Ambiguous < Error
+    end
+
+    class AlreadyInstalled < Error
+    end
+
+    def self.host_platform: (?host_os: String, ?host_cpu: String) -> String
+
+    class Installation < Data
+      METADATA_FILE: String
+      RECORDED: Array[Symbol]
+
+      attr_reader version: String
+      attr_reader tier: String
+      attr_reader platform: String
+      attr_reader path: String
+      attr_reader build_date: String?
+      attr_reader git_sha: String?
+      attr_reader sha256: String?
+      attr_reader source: String?
+      attr_reader imported_at: String?
+
+      def self.load: (String path) -> Installation
+      def id: () -> String
+      def gem_version: () -> Gem::Version
+      def built_on: () -> String?
+      def write_metadata: (?String dir) -> void
+    end
+
+    class Spec < Data
+      PATTERN: Regexp
+
+      attr_reader version: String
+      attr_reader tier: String?
+      attr_reader platform: String?
+
+      def self.parse: (String string) -> Spec
+      def match?: (Installation installation) -> bool
+    end
+
+    class Inspector
+      CHANGELOG: String
+      VERSION_FILE: String
+      BINARIES: Array[String]
+
+      def self.find_root: (String dir) -> String
+      def self.engine_root?: (String dir) -> bool
+      def initialize: (String root, ?hints: Array[String], ?tier: String?, ?platform: String?) -> void
+      def details: () -> Hash[Symbol, String?]
+    end
+
+    class Store
+      attr_reader root: String
+
+      def initialize: (String root, ?host_platform: String) -> void
+      def installations: () -> Array[Installation]
+      def get: (String id) -> Installation?
+      def find: (String | Spec spec) -> Installation
+      def find_native: (Spec spec, ?default_tier: String?) -> Installation
+      def latest_native: () -> Installation?
+      def path_for: (String id) -> String
+      def remove: (Installation installation) -> void
+      def stage: [T] () { (String dir) -> T } -> T
+    end
+
+    class Importer
+      class Result < Data
+        attr_reader installation: Installation
+        attr_reader status: Symbol
+      end
+
+      def initialize: (Store store, ?tier: String?, ?platform: String?, ?force: bool) -> void
+      def import: (String source) -> Result
+    end
+
+    class Materializer
+      MANIFEST: String
+      GAME_ONLY_FILES: Array[String]
+      SKIPPED: Array[String]
+      SKIPPED_NAMES: Array[String]
+
+      class Conflict < Error
+      end
+
+      class Manifest < Data
+        attr_reader engine: String?
+        attr_reader files: Array[String]
+      end
+
+      class Result < Data
+        attr_reader copied: Integer
+        attr_reader removed: Integer
+        attr_reader cloned: Integer
+      end
+
+      def initialize: (Project project) -> void
+      def manifest: () -> Manifest?
+      def files_for: (Installation installation) -> Array[String]
+      def conflicts: (Installation installation) -> Array[String]
+      def install: (Installation installation, ?force: bool) -> Result
+    end
+
+    module Fetchers
+      ZIP_MAGIC: String
+
+      def self.for: (String tier, **untyped options) -> (DragonRubyAPI | ItchJam | Butler)
+      def self.zip?: (String path) -> bool
+      def self.download_zip: (HTTP http, String url, String path, ?auth: HTTP::Auth?) ?{ (Integer, Integer?) -> void } -> String
+
+      class DragonRubyAPI
+        API: String
+        OS_NAMES: Hash[String, String]
+
+        attr_reader tier: String
+
+        def initialize: (String tier, ?http: HTTP, ?downloads_dir: String, ?platform: String, ?api: String) -> void
+        def credentials?: () -> bool
+        def api_url: () -> String
+        def verify: (Credentials credentials) -> void
+        def fetch: (credentials: Credentials?) ?{ (Integer received, Integer? total) -> void } -> String
+      end
+
+      class ItchJam
+        PAGE: String
+        UPLOADS: Hash[String, String]
+
+        def initialize: (?http: HTTP, ?downloads_dir: String, ?platform: String, ?page: String) -> void
+        def tier: () -> String
+        def credentials?: () -> bool
+        def fetch: (?credentials: Credentials?) ?{ (Integer received, Integer? total) -> void } -> String
+      end
+
+      class Butler
+        GAME: String
+
+        def initialize: (?platform: String, ?downloads_dir: String, ?butler: String) -> void
+        def tier: () -> String
+        def credentials?: () -> bool
+        def fetch: (?credentials: Credentials?) -> String
+      end
+    end
+
+    module GitIgnore
+      BEGIN_MARKER: String
+      END_MARKER: String
+      BLOCK: Regexp
+
+      def self.patterns: (Array[String] files) -> Array[String]
+      def self.block?: (String path) -> bool
+      def self.write: (String path, Array[String] files) -> void
+      def self.refresh: (String path, Array[String] files) -> bool
+    end
+  end
+
+  class TestReport < Data
+    SUMMARY: Regexp
+    EXCEPTION: Regexp
+    NO_TESTS: String
+    ENGINE_LINE: Regexp
+
+    attr_reader status: (:passed | :failed | :error | :no_tests | :timeout)
+    attr_reader passed: Integer
+    attr_reader failed: Integer
+    attr_reader inconclusive: Integer
+    attr_reader details: String
+    attr_reader output: String
+
+    def self.parse: (String output) -> TestReport
+    def self.timeout: (String output) -> TestReport
+    def passed?: () -> bool
+  end
+
+  class Runner
+    GENERATED_DIRS: Array[String]
+    TEST_PATTERN: String
+    TEST_DIRS: Array[String]
+    HEADLESS_ENV: Hash[String, String]
+
+    class MissingBinary < Error
+    end
+
+    def self.exec_process: (Array[String] argv, chdir: String) -> bot
+
+    def initialize: (Project project) -> void
+    def binary: (?String name) -> String
+    def game_arg: () -> String
+    def run_command: (?Array[String] args) -> Array[String]
+    def build_command: (?Array[String] args) -> Array[String]
+    def serve_command: (String dir, Integer port) -> Array[String]
+    def test_command: (String file) -> Array[String]
+    def html5_build: () -> String?
+    def test_files: (?Array[String] paths, ?base: String) -> Array[String]
+    def run_test: (String file, ?timeout: Numeric, ?headless: bool) -> TestReport
+    def clean: () -> Array[String]
+  end
+
+  module Deps
+    class FetchError < Error
+    end
+
+    class ManifestError < Error
+    end
+
+    class ModifiedError < Error
+    end
+
+    def self.parse_source: (String source) -> [Symbol, String]
+    def self.declaration: (Symbol kind, String value, ?path: String?, ?ref: String?, ?as: String?) -> String
+    def self.require_hint: (Project project, Dependency dependency) -> String?
+
+    class Git
+      FULL_SHA: Regexp
+
+      def resolve: (String url, String? ref) -> String
+      def checkout: (String url, String commit, String dir) -> void
+    end
+
+    module Tree
+      def self.checksum: (String path) -> String?
+      def self.copy_subpath: (String root, String? subpath, String target) -> void
+      def self.untar: (String data, String dir, ?strip: Integer) -> void
+    end
+
+    class Context < Data
+      attr_reader http: DrTalon::HTTP
+      attr_reader git: Git
+      attr_reader github_url: String
+      attr_reader codeload_url: String
+
+      def self.default: () -> Context
+    end
+
+    class Dependency
+      VENDOR: String
+
+      attr_reader name: String
+      attr_reader destination: String
+      attr_reader ref: String?
+      attr_reader line: Integer?
+
+      def initialize: (?name: String?, ?destination: String?, ?ref: String?, ?line: Integer?) -> void
+      def key: () -> String
+      def lockable?: () -> bool
+      def resolve: (Context context) -> String?
+      def fetch: (Context context, String? commit, String target) -> void
+    end
+
+    class GitHubDependency < Dependency
+      attr_reader owner: String
+      attr_reader repo: String
+      attr_reader subpath: String
+    end
+
+    class GitDependency < Dependency
+      attr_reader url: String
+      attr_reader subpath: String
+    end
+
+    class URLDependency < Dependency
+      attr_reader url: String
+    end
+
+    class PathDependency < Dependency
+      attr_reader path: String
+    end
+
+    class Lock < Data
+      attr_reader key: String
+      attr_reader ref: String?
+      attr_reader destination: String
+      attr_reader commit: String?
+      attr_reader checksum: String?
+
+      def self.parse: (String line) -> Lock?
+      def to_line: () -> String
+    end
+
+    class Manifest
+      FILE: String
+      SEPARATOR: Regexp
+      LOCK_HEADER: String
+
+      attr_reader path: String
+      attr_reader config: String
+      attr_reader dependencies: Array[Dependency]
+      attr_reader locks: Array[Lock]
+      attr_reader foodchain_locks: bool
+
+      def self.for: (Project project) -> Manifest
+      def initialize: (String path) -> void
+      def exist?: () -> bool
+      def find: (String name) -> Dependency?
+      def write_locks: (Array[Lock] locks) -> void
+      def add: (String line) -> void
+      def remove: (Dependency dependency) -> void
+    end
+
+    class DSL
+      METHODS: Array[String]
+
+      def self.evaluate: (String source, String file) -> Array[Dependency]
+    end
+
+    class Installer
+      class Change < Data
+        attr_reader name: String
+        attr_reader action: (:installed | :updated | :unchanged | :restored | :removed | :kept)
+        attr_reader dependency: Dependency?
+        attr_reader commit: String?
+        attr_reader previous: String?
+      end
+
+      def initialize: (Project project, ?context: Context, ?force: bool) -> void
+      def install: (?update: (Array[String] | true)?) -> Array[Change]
+      def outdated: () -> Array[Hash[Symbol, untyped]]
+      def problems: () -> Array[Hash[Symbol, untyped]]
+    end
+  end
+
+  module TalonFramework
+    REPOSITORY: String
+    GITHUB_KEY: Regexp
+    REQUIRE: String
+    BEGIN_MARKER: String
+    END_MARKER: String
+    BLOCK: Regexp
+    KIND_ORDER: Array[String]
+
+    class NotUsed < Error
+    end
+
+    def self.dependency: (Project project) -> Deps::Dependency?
+    def self.used_by?: (Project project) -> bool
+    def self.require_path: (Project project) -> String
+    def self.require_used!: (Project project) -> void
+    def self.add_require: (String main_rb, String line) -> (:added | :present | :no_block)
+    def self.names: (String name) -> [String, String]
+  end
+
+  module Generators
+    class TalonCode < Thor::Group
+      KINDS: Array[String]
+
+      def self.source_root: () -> String
+      def class_name: () -> String
+      def file_name: () -> String
+      def code_path: () -> String
+      def test_path: () -> String
+      def talon_require: () -> String
+    end
+
+    class NewProject < Thor::Group
+      TEMPLATES: Array[String]
+      NAME_PATTERN: Regexp
+
+      def self.source_root: () -> String
+      def name: () -> String
+      def file_name: () -> String
+      def module_name: () -> String
+      def title: () -> String
+      def template_name: () -> String
+      def layout: () -> (:full | :game_only)
+      def talon?: () -> bool
+      def tooling_template: () -> String
+      def engine: () -> Engine::Installation
+      def commit_engine?: () -> bool
+    end
+  end
+
+  class CLI < Thor
+    def self.exit_on_failure?: () -> bool
+    def version: () -> void
+    def new: (String path) -> void
+    def run_game: (*String args) -> void
+    def test: (*String paths) -> void
+    def build: (*String args) -> void
+    def serve: (?String? dir) -> void
+    def clean: () -> void
+    def install: () -> void
+    def update: (*String names) -> void
+    def add: (String source) -> void
+    def remove: (String name) -> void
+    def outdated: () -> void
+    def doctor: () -> void
+
+    class Generate < Thor
+      def self.exit_on_failure?: () -> bool
+      def scene: (String name) -> void
+      def component: (String name) -> void
+      def prefab: (String name) -> void
+    end
+
+    class Engine < Thor
+      def self.exit_on_failure?: () -> bool
+      def import: (String path) -> void
+      def list: () -> void
+      def which: (?String? spec) -> void
+      def fetch: () -> void
+      def login: () -> void
+      def logout: () -> void
+      def use: (?String? spec) -> void
+      def current: () -> void
+      def uninstall: (String spec) -> void
+    end
+  end
+end