dr_talon 0.1.0

data/lib/dr_talon/generators/new_project.rb

@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module DrTalon
+  module Generators
+    # +talon new PATH+: creates a game (+bare+ template, DragonRuby's full
+    # layout) or a library (+lib+ template, game-only layout) with a pinned,
+    # installed engine.
+    #
+    # Each public method is a step, run in order by {Thor::Group#invoke_all}.
+    class NewProject < Thor::Group
+      include Thor::Actions
+
+      TEMPLATES = %w[bare lib talon].freeze
+      NAME_PATTERN = /\A[A-Za-z][A-Za-z0-9_-]*\z/
+
+      argument :path, type: :string, desc: "Directory to create; its name is the project name"
+
+      class_option :template, type: :string,
+        desc: "bare (a game), talon (a game on the Talon framework) or lib (a library); default from config.yml, else bare"
+      class_option :lib, type: :boolean, default: false, desc: "Shorthand for --template lib"
+      class_option :engine, type: :string, desc: "Engine to pin, e.g. 7.23-pro (default: the newest cached)"
+      class_option :commit_engine, type: :boolean,
+        desc: "Commit the engine to git instead of ignoring it and restoring with `talon engine use` (asked if omitted)"
+      class_option :title, type: :string, desc: "Game title for game_metadata.txt (default: from the name)"
+      class_option :dev_id, type: :string, desc: "itch.io username for game_metadata.txt (default: from config.yml)"
+      class_option :dev_title, type: :string, desc: "Developer display name for game_metadata.txt (default: from config.yml)"
+      class_option :skip_git, type: :boolean, default: false, desc: "Don't run git init"
+      class_option :skip_bundle, type: :boolean, default: false, desc: "Don't run bundle install"
+      class_option :skip_deps, type: :boolean, default: false, desc: "Don't vendor dependencies (the talon template's Talon)"
+
+      def self.source_root
+        File.expand_path("../templates", __dir__)
+      end
+
+      def check_destination
+        raise Error, "Invalid project name \"#{name}\". Use letters, digits, - and _, starting with a letter." unless NAME_PATTERN.match?(name)
+        raise Error, "Unknown template \"#{template_name}\". Expected one of #{TEMPLATES.join(", ")}." unless TEMPLATES.include?(template_name)
+
+        root = File.expand_path(path)
+        raise Error, "#{root} already exists and isn't empty." if File.exist?(root) && !(File.directory?(root) && Dir.empty?(root))
+
+        self.destination_root = root
+      end
+
+      def resolve_engine
+        engine
+      end
+
+      def ask_about_committing_engine
+        commit_engine?
+      end
+
+      def create_game
+        (layout == :full) ? copy_stock_game : create_library
+        template "bare/main_tests.rb.tt", "mygame/tests/main_tests.rb" if template_name == "bare"
+        create_talon_game if talon?
+      end
+
+      def create_tooling
+        template "shared/Gemfile.tt", "Gemfile"
+        template "shared/editorconfig.tt", ".editorconfig"
+        template "shared/gitignore.tt", ".gitignore"
+        template "shared/README.md.tt", "README.md"
+        template "#{tooling_template}/rubocop.yml.tt", ".rubocop.yml"
+        template "#{tooling_template}/solargraph.yml.tt", ".solargraph.yml"
+      end
+
+      def fill_metadata
+        return unless layout == :full
+
+        file = File.join(destination_root, "mygame", "metadata", "game_metadata.txt")
+        return unless File.file?(file)
+
+        values = {
+          "devid" => options[:dev_id] || config.dev_id ||
+            ask_in_terminal("Your itch.io username, for game_metadata.txt (blank to set it later):"),
+          "devtitle" => options[:dev_title] || config.dev_title ||
+            ask_in_terminal("Your name as shown in builds (blank to set it later):"),
+          "gameid" => name.downcase.tr("_", "-"),
+          "gametitle" => title,
+          "version" => "0.1",
+          "icon" => "metadata/icon.png"
+        }.compact
+
+        content = values.reduce(File.read(file)) do |text, (key, value)|
+          # Set the first assignment, uncommenting DragonRuby's "# key=..." form.
+          text.sub(/^[ \t]*(?:#[ \t]*)?#{Regexp.escape(key)}=.*$/) { "#{key}=#{value}" }
+        end
+        File.write(file, content)
+        say_status :update, "mygame/metadata/game_metadata.txt"
+      end
+
+      def install_engine
+        project = Project.new(destination_root)
+        materializer = Engine::Materializer.new(project)
+        result = materializer.install(engine)
+        project.pin!(engine)
+        say_status :engine, "#{engine.id} (#{result.copied} files)"
+        say_status :create, Project::PIN_FILE
+
+        Engine::GitIgnore.write(File.join(destination_root, ".gitignore"), materializer.manifest.files) unless commit_engine?
+      end
+
+      def install_dependencies
+        return unless talon? && !options[:skip_deps]
+
+        changes = Deps::Installer.new(Project.new(destination_root)).install
+        changes.each { |change| say_status :vendor, "#{change.name} (#{change.dependency&.key})" }
+      rescue DrTalon::Error => e
+        say_status :skip, "vendoring Talon failed (#{e.message}); run `talon install` when you're online", :yellow
+      end
+
+      def git_init
+        return if options[:skip_git]
+        return say_status(:skip, "git init (git not found)", :yellow) unless executable?("git")
+
+        inside(destination_root) { run "git init --quiet", abort_on_failure: false }
+      end
+
+      def bundle_install
+        return if options[:skip_bundle]
+        return say_status(:skip, "bundle install (bundler not found)", :yellow) unless executable?("bundle")
+
+        # Run against the new Gemfile, not whichever bundle talon runs in.
+        if defined?(Bundler)
+          Bundler.with_unbundled_env { bundle_in_destination }
+        else
+          bundle_in_destination
+        end
+      end
+
+      def print_next_steps
+        relative = path
+        say ""
+        say "Created #{name} with DragonRuby #{engine.id}.", :green
+        say "  cd #{relative}"
+        say((layout == :full) ? "  talon run" : "  talon test")
+        say "  talon generate scene NAME" if talon?
+        say "  talon doctor"
+      end
+
+      no_commands do
+        def name
+          File.basename(File.expand_path(path))
+        end
+
+        # @return [String] the name as a Ruby file name: my-lib -> my_lib
+        def file_name
+          name.tr("-", "_")
+        end
+
+        def module_name
+          name.split(/[-_]/).map { |part| part[0].upcase + part[1..] }.join
+        end
+
+        def title
+          options[:title] || name.split(/[-_]/).map(&:capitalize).join(" ")
+        end
+
+        def template_name
+          @template_name ||= options[:lib] ? "lib" : (options[:template] || config.default_template)
+        end
+
+        def layout
+          (template_name == "lib") ? :game_only : :full
+        end
+
+        def talon?
+          template_name == "talon"
+        end
+
+        # The talon template is a bare game plus Talon.
+        def tooling_template
+          talon? ? "bare" : template_name
+        end
+
+        def talon_require
+          TalonFramework::REQUIRE
+        end
+
+        def talon_repository
+          TalonFramework::REPOSITORY
+        end
+
+        def requires_block
+          [TalonFramework::BEGIN_MARKER, %(require "app/components/spin.rb"), %(require "app/scenes/title.rb"),
+            TalonFramework::END_MARKER].join("\n")
+        end
+
+        def dependencies_hint
+          (layout == :full) ? "mygame/vendor/" : "vendor/"
+        end
+
+        def engine
+          @engine ||=
+            if options[:engine]
+              store.find_native(Engine::Spec.parse(options[:engine]))
+            else
+              store.latest_native || raise(Engine::NotFound,
+                "No #{Engine.host_platform} engine is cached. Import one first: talon engine import <zip>")
+            end
+        end
+
+        # Asked once unless --commit-engine/--no-commit-engine was given.
+        # Libraries default to not committing: DragonRuby asks that public
+        # repos not include its tooling.
+        def commit_engine?
+          return @commit_engine unless @commit_engine.nil?
+
+          @commit_engine =
+            if !options[:commit_engine].nil?
+              options[:commit_engine]
+            elsif layout == :game_only
+              false
+            else
+              yes?("Commit the DragonRuby engine to git? DragonRuby recommends it for private/commercial games. " \
+                "If not, it's gitignored and restored with `talon engine use`. [y/N]")
+            end
+        end
+
+        def config
+          @config ||= Config.load
+        end
+
+        def store
+          @store ||= Engine::Store.new(Paths.new.engines_dir)
+        end
+      end
+
+      private
+
+      def copy_stock_game
+        source = File.join(engine.path, "mygame")
+        raise Engine::InvalidEngine, "#{engine.id} has no mygame/ to start from." unless File.directory?(source)
+
+        Dir.glob("**/*", File::FNM_DOTMATCH, base: source).sort.each do |relative|
+          next if File.basename(relative).match?(/\A\.\.?\z/) || File.basename(relative) == ".DS_Store"
+
+          from = File.join(source, relative)
+          to = File.join(destination_root, "mygame", relative)
+          if File.directory?(from)
+            FileUtils.mkdir_p(to)
+          else
+            FileUtils.mkdir_p(File.dirname(to))
+            FileCopy.copy(from, to)
+          end
+        end
+        say_status :create, "mygame (from #{engine.id})"
+      end
+
+      def create_talon_game
+        template "talon/game/main.rb.tt", "mygame/app/main.rb", force: true
+        template "talon/game/title.rb.tt", "mygame/app/scenes/title.rb"
+        template "talon/game/spin.rb.tt", "mygame/app/components/spin.rb"
+        template "talon/game/title_tests.rb.tt", "mygame/tests/scenes/title_tests.rb"
+        template "talon/game/dependencies.rb.tt", "mygame/dependencies.rb"
+      end
+
+      def create_library
+        template "lib/app/main.rb.tt", "app/main.rb"
+        template "lib/lib/library.rb.tt", "lib/#{file_name}.rb"
+        template "lib/lib/version.rb.tt", "lib/#{file_name}/version.rb"
+        template "lib/test/test_helper.rb.tt", "test/test_helper.rb"
+        template "lib/test/tests.rb.tt", "test/#{file_name}_tests.rb"
+      end
+
+      # dragonruby-publish needs devid and devtitle, so ask for them in a
+      # terminal; scripts and CI aren't prompted.
+      def ask_in_terminal(question)
+        return nil unless $stdin.tty?
+
+        answer = ask(question).to_s.strip
+        answer.empty? ? nil : answer
+      end
+
+      def bundle_in_destination
+        inside(destination_root) { run "bundle install --quiet", abort_on_failure: false }
+      end
+
+      def executable?(command)
+        ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).any? do |dir|
+          File.executable?(File.join(dir, command)) && !File.directory?(File.join(dir, command))
+        end
+      end
+    end
+  end
+end

data/lib/dr_talon/generators/talon_code.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module DrTalon
+  module Generators
+    # +talon generate scene|component|prefab NAME+: a Talon class in
+    # app/<kind>s/, a DragonRuby test in tests/<kind>s/, and its require in
+    # app/main.rb's managed block.
+    class TalonCode < Thor::Group
+      include Thor::Actions
+
+      KINDS = %w[scene component prefab].freeze
+
+      argument :kind, type: :string, desc: KINDS.join(", ")
+      argument :name, type: :string, desc: "e.g. MainMenu or main_menu"
+
+      class_option :skip_test, type: :boolean, default: false, desc: "Don't create a test"
+      class_option :force, type: :boolean, default: false, desc: "Overwrite existing files"
+
+      def self.source_root
+        File.expand_path("../templates/talon/generate", __dir__)
+      end
+
+      def check
+        raise Error, "Unknown kind \"#{kind}\". Expected one of #{KINDS.join(", ")}." unless KINDS.include?(kind)
+
+        TalonFramework.require_used!(project)
+        self.destination_root = project.game_dir
+
+        existing = files.select { |path| File.exist?(File.join(destination_root, path)) }
+        return if existing.empty? || options[:force]
+
+        raise Error, "#{existing.join(" and ")} already exist#{"s" if existing.one?}. Pass --force to overwrite."
+      end
+
+      def create_code
+        template "#{kind}.rb.tt", code_path, force: options[:force]
+      end
+
+      def create_test
+        template "#{kind}_tests.rb.tt", test_path, force: options[:force] unless options[:skip_test]
+      end
+
+      def add_require
+        main = File.join(destination_root, "app", "main.rb")
+        line = %(require "#{file_require}")
+
+        case TalonFramework.add_require(main, line)
+        when :added then say_status :update, "app/main.rb (#{line})"
+        when :present then say_status :identical, "app/main.rb (#{line})", :blue
+        else
+          say "\nAdd this to app/main.rb (it has no `talon generate` block):\n  #{line}"
+        end
+      end
+
+      no_commands do
+        def project
+          @project ||= Project.locate
+        end
+
+        def class_name
+          TalonFramework.names(name).first
+        end
+
+        def file_name
+          TalonFramework.names(name).last
+        end
+
+        def code_path
+          "app/#{kind}s/#{file_name}.rb"
+        end
+
+        def test_path
+          "tests/#{kind}s/#{file_name}_tests.rb"
+        end
+
+        def file_require
+          code_path
+        end
+
+        def talon_require
+          TalonFramework.require_path(project)
+        end
+
+        def files
+          options[:skip_test] ? [code_path] : [code_path, test_path]
+        end
+      end
+    end
+  end
+end

data/lib/dr_talon/http.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module DrTalon
+  # Minimal HTTP(S) GETs with redirects, for dependencies and engine
+  # downloads. Basic auth is only sent to the host it was given for.
+  class HTTP
+    MAX_REDIRECTS = 5
+
+    # A request failed or returned a non-2xx status.
+    class Error < DrTalon::Error; end
+
+    # The server answered 401.
+    class Unauthorized < Error; end
+
+    Auth = Data.define(:username, :password)
+
+    # @param url [String]
+    # @param auth [Auth, nil]
+    # @return [String] the response body
+    # @raise [Error]
+    def get(url, auth: nil)
+      follow(url, auth) { |response| return response.body.to_s }
+    end
+
+    # Posts a form and returns the body (no redirects).
+    #
+    # @param url [String]
+    # @param form [Hash{String => String}]
+    # @return [String]
+    # @raise [Error]
+    def post_form(url, form)
+      uri = http_uri(url)
+      request = Net::HTTP::Post.new(uri, headers)
+      request.set_form_data(form)
+      perform(uri, request) do |response|
+        check!(uri, response)
+        raise Error, "POST #{uri} returned #{response.code} #{response.message}" unless response.is_a?(Net::HTTPSuccess)
+
+        return response.body.to_s
+      end
+    end
+
+    # Streams a response body to +path+.
+    #
+    # @param url [String]
+    # @param path [String]
+    # @param auth [Auth, nil]
+    # @yieldparam received [Integer] bytes so far
+    # @yieldparam total [Integer, nil] Content-Length, if sent
+    # @return [String] +path+
+    # @raise [Error]
+    def download(url, path, auth: nil)
+      follow(url, auth) do |response|
+        total = response.content_length
+        received = 0
+        File.open(path, "wb") do |file|
+          response.read_body do |chunk|
+            file.write(chunk)
+            received += chunk.bytesize
+            yield received, total if block_given?
+          end
+        end
+        return path
+      end
+    end
+
+    private
+
+    # Yields the first successful response; the caller reads its body.
+    def follow(url, auth)
+      uri = http_uri(url)
+      origin = uri.host
+
+      (MAX_REDIRECTS + 1).times do
+        redirect = nil
+        request = Net::HTTP::Get.new(uri, headers)
+        request.basic_auth(auth.username, auth.password) if auth && uri.host == origin
+        perform(uri, request) do |response|
+          check!(uri, response)
+          case response
+          when Net::HTTPSuccess then yield response
+          when Net::HTTPRedirection then redirect = http_uri(URI.join(uri, response["location"]))
+          else raise Error, "GET #{uri} returned #{response.code} #{response.message}"
+          end
+        end
+        uri = redirect
+      end
+
+      raise Error, "GET #{url} redirected more than #{MAX_REDIRECTS} times"
+    end
+
+    def http_uri(url)
+      uri = URI(url)
+      raise Error, "Only http(s) URLs are supported: #{url}" unless uri.is_a?(URI::HTTP)
+
+      uri
+    rescue URI::InvalidURIError => e
+      raise Error, "Invalid URL #{url}: #{e.message}"
+    end
+
+    def headers
+      {"User-Agent" => "dr_talon/#{VERSION}"}
+    end
+
+    def check!(uri, response)
+      raise Unauthorized, "#{uri.host} rejected the username or password (401)" if response.is_a?(Net::HTTPUnauthorized)
+    end
+
+    def perform(uri, request, &block)
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https", open_timeout: 15, read_timeout: 120) do |http|
+        http.request(request, &block)
+      end
+    rescue SocketError, SystemCallError, Timeout::Error, OpenSSL::SSL::SSLError, Net::ProtocolError => e
+      raise Error, "#{request.method} #{uri} failed: #{e.message}"
+    end
+  end
+end

data/lib/dr_talon/paths.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module DrTalon
+  # Resolves where talon keeps its global state: cached engines, downloads,
+  # config and credentials.
+  #
+  # - Linux/BSD: XDG base directories (+XDG_DATA_HOME+, +XDG_CACHE_HOME+,
+  #   +XDG_CONFIG_HOME+), defaulting to +~/.local/share+, +~/.cache+ and
+  #   +~/.config+.
+  # - macOS: +~/Library/Application Support+ and +~/Library/Caches+, unless
+  #   the XDG variables are set explicitly.
+  # - Windows: +%LOCALAPPDATA%+ for data and cache, +%APPDATA%+ for config.
+  #
+  # Setting +DR_TALON_HOME+ puts everything under that one directory, which is
+  # handy for tests and for isolating experiments.
+  class Paths
+    APP_NAME = "dr_talon"
+
+    # @param env [Hash{String => String}] environment to read overrides from
+    # @param host_os [String] value of +RbConfig::CONFIG["host_os"]+
+    # @param home [String] the user's home directory
+    def initialize(env: ENV, host_os: RbConfig::CONFIG["host_os"], home: Dir.home)
+      @env = env
+      @platform = platform_for(host_os)
+      @home = home
+    end
+
+    # @return [String] root for persistent data such as cached engines
+    def data_dir
+      @data_dir ||= resolve(:data)
+    end
+
+    # @return [String] root for disposable files such as downloaded zips
+    def cache_dir
+      @cache_dir ||= resolve(:cache)
+    end
+
+    # @return [String] root for user configuration
+    def config_dir
+      @config_dir ||= resolve(:config)
+    end
+
+    # @return [String] where unpacked engines are stored
+    def engines_dir
+      File.join(data_dir, "engines")
+    end
+
+    # @return [String] where downloaded engine zips are kept
+    def downloads_dir
+      File.join(cache_dir, "downloads")
+    end
+
+    # @return [String]
+    def config_file
+      File.join(config_dir, "config.yml")
+    end
+
+    # @return [String] dragonruby.org credentials, written with mode 0600
+    def credentials_file
+      File.join(config_dir, "credentials.yml")
+    end
+
+    private
+
+    XDG_VARS = {data: "XDG_DATA_HOME", cache: "XDG_CACHE_HOME", config: "XDG_CONFIG_HOME"}.freeze
+    XDG_DEFAULTS = {data: [".local", "share"], cache: [".cache"], config: [".config"]}.freeze
+
+    def resolve(kind)
+      if (root = present(@env["DR_TALON_HOME"]))
+        return File.join(root, kind.to_s)
+      end
+
+      case @platform
+      when :windows then windows_dir(kind)
+      when :macos then present(@env[XDG_VARS[kind]]) ? xdg_dir(kind) : macos_dir(kind)
+      else xdg_dir(kind)
+      end
+    end
+
+    def xdg_dir(kind)
+      base = present(@env[XDG_VARS[kind]]) || File.join(@home, *XDG_DEFAULTS[kind])
+      File.join(base, APP_NAME)
+    end
+
+    def macos_dir(kind)
+      base = (kind == :cache) ? "Caches" : "Application Support"
+      File.join(@home, "Library", base, APP_NAME)
+    end
+
+    def windows_dir(kind)
+      local = present(@env["LOCALAPPDATA"]) || File.join(@home, "AppData", "Local")
+      roaming = present(@env["APPDATA"]) || File.join(@home, "AppData", "Roaming")
+
+      case kind
+      when :data then File.join(local, APP_NAME)
+      when :cache then File.join(local, APP_NAME, "cache")
+      when :config then File.join(roaming, APP_NAME)
+      end
+    end
+
+    def platform_for(host_os)
+      case host_os
+      when /darwin/ then :macos
+      when /mswin|mingw|cygwin/ then :windows
+      else :unix
+      end
+    end
+
+    def present(value)
+      value unless value.nil? || value.empty?
+    end
+  end
+end