dama 0.1.0

data/lib/dama/release/packager/macos.rb

@@ -0,0 +1,99 @@
+require "cgi"
+require "fileutils"
+
+module Dama
+  module Release
+    module Packager
+      # Creates a self-contained macOS .app bundle containing
+      # the Ruby runtime, gems, native library, game code, and assets.
+      class Macos
+        def initialize(project_root:)
+          @project_root = project_root
+          @metadata = GameMetadata.new(project_root:)
+          @icon_provider = IconProvider.new(project_root:, platform: :macos)
+        end
+
+        def package
+          native_library_path = NativeBuilder.new.build
+          prepare_app_structure
+          ruby_path = RubyBundler.new(destination: resources_path, project_root:).bundle
+          relink_dylibs(ruby_path:)
+          FileUtils.cp(native_library_path, resources_path)
+          GameFileCopier.new(project_root:, destination: resources_path).copy
+          copy_icon
+          write_info_plist
+          write_launcher_script(native_library_path:)
+
+          archive_path = Archiver.new(source_path: app_path).create_macos_zip
+          puts "macOS release created: #{archive_path}"
+        end
+
+        private
+
+        attr_reader :project_root, :metadata, :icon_provider
+
+        def app_name
+          "#{metadata.release_name}.app"
+        end
+
+        def app_path
+          File.join(project_root, "release", app_name)
+        end
+
+        def contents_path
+          File.join(app_path, "Contents")
+        end
+
+        def resources_path
+          File.join(contents_path, "Resources")
+        end
+
+        def macos_path
+          File.join(contents_path, "MacOS")
+        end
+
+        def prepare_app_structure
+          FileUtils.rm_rf(app_path)
+          FileUtils.mkdir_p(macos_path)
+          FileUtils.mkdir_p(resources_path)
+        end
+
+        # Rewrites hardcoded absolute dylib paths in the bundled Ruby binary
+        # to use @loader_path-relative references, so the .app works on any Mac.
+        def relink_dylibs(ruby_path:)
+          ruby_binary_name = RbConfig::CONFIG.fetch("ruby_install_name")
+          ruby_binary_path = File.join(ruby_path, "bin", ruby_binary_name)
+          lib_destination = File.join(ruby_path, "lib")
+          DylibRelinker.new(binary_path: ruby_binary_path, lib_destination:).relink
+        end
+
+        def copy_icon
+          icon_source = icon_provider.icon_path
+          FileUtils.cp(icon_source, File.join(resources_path, "icon.icns")) if File.exist?(icon_source)
+        end
+
+        def write_info_plist
+          content = TemplateRenderer.new(
+            template_name: "info_plist.xml.erb",
+            variables: { escaped_title: CGI.escapeHTML(metadata.title) },
+          ).render
+          File.write(File.join(contents_path, "Info.plist"), content)
+        end
+
+        def write_launcher_script(native_library_path:)
+          launcher_path = File.join(macos_path, "launch")
+          content = TemplateRenderer.new(
+            template_name: "launcher_macos.sh.erb",
+            variables: {
+              native_lib_name: File.basename(native_library_path),
+              ruby_version: RbConfig::CONFIG.fetch("ruby_version"),
+              ruby_arch: RbConfig::CONFIG.fetch("arch"),
+            },
+          ).render
+          File.write(launcher_path, content)
+          FileUtils.chmod(0o755, launcher_path)
+        end
+      end
+    end
+  end
+end

data/lib/dama/release/packager/web.rb

@@ -0,0 +1,32 @@
+require "fileutils"
+
+module Dama
+  module Release
+    module Packager
+      # Produces a web-deployable build by delegating to
+      # WebBuilder, then copying the output to release/web/.
+      class Web
+        def initialize(project_root:)
+          @project_root = project_root
+        end
+
+        def package
+          builder = Dama::WebBuilder.new(project_root:)
+          builder.build
+
+          release_dir = File.join(project_root, "release", "web")
+          FileUtils.rm_rf(release_dir)
+          FileUtils.mkdir_p(File.dirname(release_dir))
+          FileUtils.cp_r(File.join(project_root, "dist"), release_dir)
+
+          archive_path = Archiver.new(source_path: release_dir).create_zip
+          puts "Web release created: #{archive_path}"
+        end
+
+        private
+
+        attr_reader :project_root
+      end
+    end
+  end
+end

data/lib/dama/release/packager/windows.rb

@@ -0,0 +1,61 @@
+require "fileutils"
+
+module Dama
+  module Release
+    module Packager
+      # Creates a self-contained Windows directory with a .bat launcher,
+      # bundled Ruby, native .dll, game files, and assets.
+      class Windows
+        def initialize(project_root:)
+          @project_root = project_root
+          @metadata = GameMetadata.new(project_root:)
+          @icon_provider = IconProvider.new(project_root:, platform: :windows)
+        end
+
+        def package
+          native_library_path = NativeBuilder.new.build
+          prepare_structure
+          RubyBundler.new(destination: release_path, project_root:).bundle
+          FileUtils.cp(native_library_path, release_path)
+          GameFileCopier.new(project_root:, destination: release_path).copy
+          copy_icon
+          write_launcher_script(native_library_path:)
+
+          archive_path = Archiver.new(source_path: release_path).create_zip
+          puts "Windows release created: #{archive_path}"
+        end
+
+        private
+
+        attr_reader :project_root, :metadata, :icon_provider
+
+        def release_path
+          File.join(project_root, "release", metadata.release_name)
+        end
+
+        def prepare_structure
+          FileUtils.rm_rf(release_path)
+          FileUtils.mkdir_p(release_path)
+        end
+
+        def copy_icon
+          icon_source = icon_provider.icon_path
+          FileUtils.cp(icon_source, File.join(release_path, "icon.ico")) if File.exist?(icon_source)
+        end
+
+        def write_launcher_script(native_library_path:)
+          launcher_path = File.join(release_path, "#{metadata.release_name}.bat")
+          content = TemplateRenderer.new(
+            template_name: "launcher_windows.bat.erb",
+            variables: {
+              native_lib_name: File.basename(native_library_path),
+              ruby_version: RbConfig::CONFIG.fetch("ruby_version"),
+              ruby_arch: RbConfig::CONFIG.fetch("arch"),
+            },
+          ).render
+          File.write(launcher_path, content)
+        end
+      end
+    end
+  end
+end

data/lib/dama/release/packager.rb

@@ -0,0 +1,9 @@
+module Dama
+  module Release
+    # Namespace for platform-specific packagers.
+    # Each packager creates a self-contained distributable
+    # for its target platform.
+    module Packager
+    end
+  end
+end

data/lib/dama/release/platform_detector.rb

@@ -0,0 +1,23 @@
+module Dama
+  module Release
+    # Resolves the current OS into a platform symbol
+    # used to select the correct packager.
+    class PlatformDetector
+      PLATFORMS = {
+        "darwin" => :macos,
+        "linux" => :linux,
+        "mingw" => :windows,
+        "mswin" => :windows,
+      }.freeze
+
+      class UnsupportedPlatformError < StandardError; end
+
+      def self.detect
+        platform_key = PLATFORMS.keys.detect { |k| RUBY_PLATFORM.include?(k) }
+        raise UnsupportedPlatformError, "Unsupported platform: #{RUBY_PLATFORM}" unless platform_key
+
+        PLATFORMS.fetch(platform_key)
+      end
+    end
+  end
+end

data/lib/dama/release/ruby_bundler.rb

@@ -0,0 +1,163 @@
+require "bundler"
+require "fileutils"
+require "rbconfig"
+
+module Dama
+  module Release
+    # Copies the Ruby runtime and gem dependencies into a release directory.
+    # Creates a self-contained Ruby environment so the packaged game
+    # can run without a system Ruby installation.
+    class RubyBundler
+      def initialize(destination:, project_root:)
+        @destination = destination
+        @project_root = project_root
+      end
+
+      def bundle
+        copy_ruby_runtime
+        install_gems
+        ruby_destination
+      end
+
+      private
+
+      attr_reader :destination, :project_root
+
+      def ruby_destination
+        File.join(destination, "ruby")
+      end
+
+      def copy_ruby_runtime
+        ruby_binary = RbConfig.ruby
+        dest_bindir = File.join(ruby_destination, "bin")
+
+        FileUtils.mkdir_p(dest_bindir)
+        FileUtils.cp(ruby_binary, File.join(dest_bindir, File.basename(ruby_binary)))
+
+        copy_shared_library
+        copy_ruby_stdlib
+      end
+
+      # Copies the Ruby shared library (e.g. libruby.3.4.dylib) into
+      # the bundle so the binary doesn't depend on the build machine's paths.
+      def copy_shared_library
+        shared_lib = RbConfig::CONFIG.fetch("LIBRUBY_SO")
+        return if shared_lib.empty?
+
+        source = File.join(RbConfig::CONFIG.fetch("libdir"), shared_lib)
+        return unless File.exist?(source)
+
+        dest_libdir = File.join(ruby_destination, "lib")
+        FileUtils.mkdir_p(dest_libdir)
+        FileUtils.cp(source, dest_libdir)
+      end
+
+      def copy_ruby_stdlib
+        rubylibdir = RbConfig::CONFIG.fetch("rubylibdir")
+        dest_libdir = File.join(ruby_destination, "lib", "ruby", RbConfig::CONFIG.fetch("ruby_version"))
+        FileUtils.mkdir_p(dest_libdir)
+        FileUtils.cp_r("#{rubylibdir}/.", dest_libdir)
+
+        archdir = RbConfig::CONFIG.fetch("archdir")
+        dest_archdir = File.join(dest_libdir, RbConfig::CONFIG.fetch("arch"))
+        FileUtils.mkdir_p(dest_archdir)
+        FileUtils.cp_r("#{archdir}/.", dest_archdir)
+
+        StdlibTrimmer.new(stdlib_dir: dest_libdir, arch_dir: dest_archdir).trim
+      end
+
+      # Runs bundle install using the project's original Gemfile so that
+      # relative path: references (e.g. path: "../..") resolve correctly
+      # against the project root, not the release directory.
+      # Uses env vars instead of CLI flags to avoid writing .bundle/config
+      # into the project directory. The --standalone flag generates a
+      # bundler/setup.rb that sets up load paths without Bundler at runtime.
+      def install_gems
+        vendor_dir = File.join(destination, "vendor", "bundle")
+        FileUtils.mkdir_p(vendor_dir)
+
+        gemfile = File.join(project_root, "Gemfile")
+        return unless File.exist?(gemfile)
+
+        Bundler.with_unbundled_env do
+          env = {
+            "BUNDLE_PATH" => vendor_dir,
+            "BUNDLE_GEMFILE" => gemfile,
+          }
+          success = system(env, "bundle", "install", "--standalone")
+          raise "Gem bundling failed" unless success
+        end
+
+        embed_path_gems(vendor_dir:, gemfile:)
+      end
+
+      # Bundler's --standalone mode generates relative paths for path: gems
+      # (e.g. path: "../..") that point back to the build machine's source tree.
+      # For a portable app bundle, we copy each path gem's lib/ into the vendor
+      # directory and rewrite setup.rb so it references the local copy.
+      def embed_path_gems(vendor_dir:, gemfile:)
+        setup_rb = File.join(vendor_dir, "bundler", "setup.rb")
+        return unless File.exist?(setup_rb)
+
+        gems = path_gem_lines(gemfile:)
+        return if gems.empty?
+
+        source_to_name = copy_path_gems(gems:, vendor_dir:)
+        rewrite_setup_rb(
+          setup_rb:,
+          bundler_dir: File.join(vendor_dir, "bundler"),
+          source_to_name:,
+        )
+      end
+
+      def copy_path_gems(gems:, vendor_dir:)
+        gems.to_h do |gem_name, source_lib|
+          embedded_lib = File.join(vendor_dir, "path_gems", gem_name, "lib")
+          FileUtils.mkdir_p(embedded_lib)
+          FileUtils.cp_r("#{source_lib}/.", embedded_lib)
+          [source_lib, gem_name]
+        end
+      end
+
+      # Rewrites path-gem entries in setup.rb to reference the embedded copies.
+      # Identifies each line's target gem by resolving its relative path back to
+      # an absolute path and matching against known source lib directories.
+      # This handles multiple path gems correctly, unlike a generic regex gsub.
+      def rewrite_setup_rb(setup_rb:, bundler_dir:, source_to_name:)
+        content = File.readlines(setup_rb).map do |line|
+          gem_name = match_path_gem(line:, bundler_dir:, source_to_name:)
+          gem_name ? path_gem_load_line(gem_name:) : line
+        end.join
+
+        File.write(setup_rb, content)
+      end
+
+      # Matches any $:.unshift line that loads from a #{__dir__}-relative path.
+      # The captured rel_path is resolved against the bundler directory to
+      # determine which path gem (if any) this line references.
+      SETUP_LOAD_PATTERN = %r{\A\$:\.\s*unshift\s+File\.expand_path\("\#\{__dir__\}/(?<rel_path>[^"]+)"\)\n?\z}
+
+      def match_path_gem(line:, bundler_dir:, source_to_name:)
+        match = line.match(SETUP_LOAD_PATTERN)
+        return unless match
+
+        resolved = File.expand_path(match[:rel_path], bundler_dir)
+        source_to_name[resolved]
+      end
+
+      def path_gem_load_line(gem_name:)
+        "$:.unshift File.expand_path(\"\#{__dir__}/../path_gems/#{gem_name}/lib\")\n"
+      end
+
+      def path_gem_lines(gemfile:)
+        File.readlines(gemfile).filter_map do |line|
+          match = line.match(/gem\s+"(?<name>[^"]+)".*path:\s*"(?<path>[^"]+)"/)
+          next unless match
+
+          gem_path = File.expand_path(match[:path], File.dirname(gemfile))
+          [match[:name], File.join(gem_path, "lib")]
+        end
+      end
+    end
+  end
+end

data/lib/dama/release/stdlib_trimmer.rb

@@ -0,0 +1,133 @@
+require "fileutils"
+
+module Dama
+  module Release
+    # Removes stdlib modules and native extensions that games don't
+    # need at runtime, reducing the bundled Ruby size by ~60%.
+    # Uses an exclusion-based approach (safer than a whitelist) so
+    # new stdlib additions aren't accidentally removed.
+    class StdlibTrimmer
+      # Pure-Ruby stdlib directories that are build tools, documentation
+      # generators, or parser infrastructure -- never needed at game runtime.
+      # Networking (net/, openssl/) and other libraries are intentionally
+      # kept since games may use them for multiplayer, asset loading, etc.
+      EXCLUDED_DIRS = %w[
+        bundler
+        did_you_mean
+        error_highlight
+        irb
+        prism
+        racc
+        rbs
+        rdoc
+        reline
+        ripper
+        ruby_vm
+        rubygems
+        syntax_suggest
+      ].freeze
+
+      # Top-level .rb files that correspond to excluded directories
+      # or standalone modules not needed at runtime.
+      EXCLUDED_FILES = %w[
+        bundler.rb
+        bundled_gems.rb
+        debug.rb
+        did_you_mean.rb
+        error_highlight.rb
+        irb.rb
+        mkmf.rb
+        prism.rb
+        rdoc.rb
+        reline.rb
+        ripper.rb
+        rubygems.rb
+        syntax_suggest.rb
+      ].freeze
+
+      # Native extensions for build/dev-only tools.
+      EXCLUDED_NATIVE_EXTENSIONS = %w[
+        ripper
+      ].freeze
+
+      def initialize(stdlib_dir:, arch_dir:)
+        @stdlib_dir = stdlib_dir
+        @arch_dir = arch_dir
+      end
+
+      def trim
+        remove_excluded_dirs
+        remove_excluded_files
+        remove_excluded_native_extensions
+        remove_debug_symbols
+        trim_encodings
+      end
+
+      private
+
+      attr_reader :stdlib_dir, :arch_dir
+
+      def remove_excluded_dirs
+        EXCLUDED_DIRS.each do |dir|
+          FileUtils.rm_rf(File.join(stdlib_dir, dir))
+        end
+      end
+
+      def remove_excluded_files
+        EXCLUDED_FILES.each do |file|
+          FileUtils.rm_f(File.join(stdlib_dir, file))
+        end
+      end
+
+      def remove_excluded_native_extensions
+        EXCLUDED_NATIVE_EXTENSIONS.each do |name|
+          Dir.glob(File.join(arch_dir, "#{name}.*")).each { |f| FileUtils.rm_rf(f) }
+          FileUtils.rm_rf(File.join(arch_dir, name))
+        end
+      end
+
+      # Debug symbol directories (.dSYM) are macOS build artifacts
+      # that add megabytes without any runtime benefit.
+      def remove_debug_symbols
+        Dir.glob(File.join(arch_dir, "**", "*.dSYM")).each do |dsym|
+          FileUtils.rm_rf(dsym)
+        end
+      end
+
+      # Ruby's encoding directory contains bundles for dozens of legacy
+      # character encodings. Games only need the encoding database
+      # (encdb) and transcoding database (transdb) that Ruby loads at boot,
+      # plus UTF-8 which is already compiled into the Ruby binary.
+      def trim_encodings
+        enc_dir = File.join(arch_dir, "enc")
+        return unless File.directory?(enc_dir)
+
+        keep_encoding_essentials(enc_dir:)
+      end
+
+      def keep_encoding_essentials(enc_dir:)
+        trans_dir = File.join(enc_dir, "trans")
+
+        essential_files = [
+          File.join(enc_dir, "encdb.bundle"),
+          File.join(enc_dir, "encdb.so"),
+        ].select { |f| File.exist?(f) }
+
+        essential_trans = [
+          File.join(trans_dir, "transdb.bundle"),
+          File.join(trans_dir, "transdb.so"),
+        ].select { |f| File.exist?(f) }
+
+        # Remove everything except the essential encoding files
+        non_essential_entries(enc_dir:, essential_files:).each { |e| FileUtils.rm_rf(e) }
+        non_essential_entries(enc_dir: trans_dir, essential_files: essential_trans).each { |e| FileUtils.rm_rf(e) }
+      end
+
+      def non_essential_entries(enc_dir:, essential_files:)
+        Dir.children(enc_dir)
+          .map { |child| File.join(enc_dir, child) }
+          .reject { |path| essential_files.include?(path) || File.directory?(path) }
+      end
+    end
+  end
+end

data/lib/dama/release/template_renderer.rb

@@ -0,0 +1,40 @@
+require "erb"
+
+module Dama
+  module Release
+    # Renders ERB templates from the templates/ directory.
+    # Separates template content (shell scripts, XML plists) from
+    # Ruby packaging logic so each can be edited independently.
+    class TemplateRenderer
+      TEMPLATES_DIR = File.expand_path("templates", __dir__)
+
+      def initialize(template_name:, variables:)
+        @template_name = template_name
+        @variables = variables
+      end
+
+      def render
+        template = ERB.new(template_content, trim_mode: "-")
+        template.result(template_binding)
+      end
+
+      private
+
+      attr_reader :template_name, :variables
+
+      def template_content
+        File.read(File.join(TEMPLATES_DIR, template_name))
+      end
+
+      # Builds a clean binding where each variable key becomes
+      # a local method, keeping templates simple and explicit.
+      def template_binding
+        namespace = Object.new
+        variables.each do |key, value|
+          namespace.define_singleton_method(key) { value }
+        end
+        namespace.instance_eval { binding }
+      end
+    end
+  end
+end

data/lib/dama/release/templates/info_plist.xml.erb

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleName</key>
+  <string><%= escaped_title %></string>
+  <key>CFBundleDisplayName</key>
+  <string><%= escaped_title %></string>
+  <key>CFBundleExecutable</key>
+  <string>launch</string>
+  <key>CFBundleIconFile</key>
+  <string>icon</string>
+  <key>CFBundlePackageType</key>
+  <string>APPL</string>
+  <key>NSHighResolutionCapable</key>
+  <true/>
+</dict>
+</plist>

data/lib/dama/release/templates/launcher_linux.sh.erb

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+DIR="$(cd "$(dirname "$0")" && pwd)"
+
+export DAMA_NATIVE_LIB="$DIR/<%= native_lib_name %>"
+export GEM_PATH="$DIR/vendor/bundle"
+export BUNDLE_GEMFILE="$DIR/Gemfile"
+export RUBYLIB="$DIR/ruby/lib/ruby/<%= ruby_version %>:$DIR/ruby/lib/ruby/<%= ruby_version %>/<%= ruby_arch %>"
+
+exec "$DIR/ruby/bin/ruby" -r "$DIR/vendor/bundle/bundler/setup.rb" \
+  -e "require 'dama'; Dama.boot(root: \"$DIR\")"

data/lib/dama/release/templates/launcher_macos.sh.erb

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+DIR="$(cd "$(dirname "$0")/../Resources" && pwd)"
+
+export DAMA_NATIVE_LIB="$DIR/<%= native_lib_name %>"
+export GEM_PATH="$DIR/vendor/bundle"
+export BUNDLE_GEMFILE="$DIR/Gemfile"
+export RUBYLIB="$DIR/ruby/lib/ruby/<%= ruby_version %>:$DIR/ruby/lib/ruby/<%= ruby_version %>/<%= ruby_arch %>"
+
+exec "$DIR/ruby/bin/ruby" -r "$DIR/vendor/bundle/bundler/setup.rb" \
+  -e "require 'dama'; Dama.boot(root: \"$DIR\")"

data/lib/dama/release/templates/launcher_windows.bat.erb

@@ -0,0 +1,11 @@
+@echo off
+set DIR=%~dp0
+if "%DIR:~-1%"=="\" set DIR=%DIR:~0,-1%
+
+set DAMA_NATIVE_LIB=%DIR%\<%= native_lib_name %>
+set GEM_PATH=%DIR%\vendor\bundle
+set BUNDLE_GEMFILE=%DIR%\Gemfile
+set RUBYLIB=%DIR%\ruby\lib\ruby\<%= ruby_version %>;%DIR%\ruby\lib\ruby\<%= ruby_version %>\<%= ruby_arch %>
+
+"%DIR%\ruby\bin\ruby.exe" -r "%DIR%\vendor\bundle\bundler\setup.rb" ^
+  -e "require 'dama'; Dama.boot(root: '%DIR%')"

data/lib/dama/release.rb

@@ -0,0 +1,7 @@
+module Dama
+  # Packaging and distribution module for dama games.
+  # Creates self-contained, distributable game packages
+  # for the current OS/architecture or web deployment.
+  module Release
+  end
+end