fastlane-plugin-godot 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6c9d11e9f58005fe0a36c6cb716b3bc3c9b783b67a268209a06387ca854bc8fa
+  data.tar.gz: 0b3982d05a6da3176b43f25bbcbec33335766bddb23c04fd7b438d5b2e718c74
+SHA512:
+  metadata.gz: f97edeb638c693b982100793757a04156ac759a43e0fc594eb62aa637929dacc96177de51ab82f87ae246ae81a9f890a48c2b1e6b394a7f0b922c0ab9004c7d4
+  data.tar.gz: 6e8a10c9ecb3258474d84323b597ebb9c4496a7a8c675f8a93fd91c66b445b3055050dea2c864b1f95cdaa34a8bd508be21cf550f1f9a75a46ddea099bbc3944

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mad Science Software
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,122 @@
+# fastlane-plugin-godot
+
+A [fastlane](https://fastlane.tools) plugin for shipping [Godot Engine](https://godotengine.org)
+games to mobile app stores: headless exports with real diagnostics, composing
+with the fastlane actions (`gym`, `pilot`, `cert`, `sigh`, `supply`, …) that
+already handle signing and store upload.
+
+**New to fastlane?** Start with the
+[Godot → TestFlight from-zero walkthrough](examples/ios-testflight/) — a
+complete copy-paste setup including Ruby installation, the App Store Connect
+API key, Godot project prep, and a working Fastfile. First setup ~30 minutes;
+~4 minutes per release after that.
+
+**Already using fastlane?**
+
+```bash
+fastlane add_plugin godot
+```
+
+## Actions
+
+### godot_init
+
+Scaffolds everything a Godot project needs for mobile releases — run once
+from the project directory:
+
+```bash
+bundle exec fastlane run godot_init
+```
+
+Creates (only when missing — existing files are never touched): `Gemfile`,
+`fastlane/{Pluginfile,Appfile,Fastfile,.env.template}`, an
+`export_presets.cfg` with iOS + Android presets, `build/.gdignore` (so Godot
+doesn't import its own build products), a placeholder 1024×1024 `app_icon.png`
+(iOS export hard-fails without an icon; pass `icon:false` to skip), and a
+`.gitignore` (or a warning listing entries yours is missing). Finishes by
+listing the placeholders you must fill in: bundle identifier, team ID, and
+your App Store Connect API key in `fastlane/.env`.
+
+### godot_export
+
+Exports a Godot project headlessly using a named export preset from
+`export_presets.cfg`, wrapping every footgun we have personally hit shipping
+a real game with it:
+
+- verifies the preset exists (and lists the available ones when it doesn't)
+- verifies the matching engine version's export templates are installed for
+  the preset's platform, with download guidance when they aren't
+- runs a headless `--import` first — a stale import cache aborts Godot
+  exports with a crash-lookalike exit 134
+- creates the output directory (Godot errors rather than create it)
+- confirms the artifact was actually produced — Godot has historically
+  exited 0 on some failed exports
+
+```ruby
+lane :beta do
+  xcodeproj = godot_export(preset: 'iOS')
+  build_app(project: xcodeproj, scheme: File.basename(xcodeproj, '.xcodeproj'))
+  upload_to_testflight
+end
+```
+
+| Option | Description | Default |
+| --- | --- | --- |
+| `preset` | Export preset name (required) | — |
+| `project_path` | Directory containing `project.godot` | `.` |
+| `godot_binary` | Path to the Godot binary | `godot` |
+| `output_path` | Artifact destination, relative to the project | the preset's `export_path` |
+| `debug` | Export a debug build | `false` |
+| `import_first` | Run headless `--import` before exporting | `true` |
+| `verbose` | Pass `--verbose` to Godot | `false` |
+
+Every option is also settable via environment variable (`FL_GODOT_*`).
+Returns the absolute artifact path (for iOS presets, the generated Xcode
+project) and sets `lane_context[:GODOT_EXPORT_OUTPUT]`.
+
+## The iOS signing story (read this once)
+
+Godot generates a fresh Xcode project on every export, with two properties
+that break naive pipelines:
+
+1. **It writes `CODE_SIGN_IDENTITY="Apple Distribution"` into an
+   automatic-signing configuration**
+   ([godot#110052](https://github.com/godotengine/godot/issues/110052)),
+   which xcodebuild rejects as conflicting. Fix: archive with
+   `xcargs: 'CODE_SIGN_IDENTITY="Apple Development"'` and let the export
+   step re-sign for distribution.
+2. **xcodebuild's cloud signing requires an Admin App Store Connect API
+   key** (`Cloud signing permission error` otherwise). You don't need it:
+   fastlane's stock `get_certificates` + `get_provisioning_profile` do
+   classic signing with an App Manager key, idempotently.
+
+The [example Fastfile](examples/ios-testflight/fastlane/Fastfile) wires both
+correctly. Its
+[README's sharp-edges table](examples/ios-testflight/README.md#known-sharp-edges-and-how-this-setup-dodges-them)
+maps the exact error messages to fixes.
+
+## Requirements
+
+- Godot 4.x available on the `PATH` (or via `godot_binary`)
+- The engine version's export templates installed for your target platform
+- For iOS builds: macOS with Xcode
+
+## Roadmap
+
+See [ROADMAP.md](ROADMAP.md) — next up: RubyGems release, version/build-number
+management actions, engine-version resolution, Android/Google Play, and
+Continuous Integration (CI) workflow templates.
+
+## Development
+
+```bash
+bundle install
+bundle exec rake   # runs the RSpec suite
+```
+
+Issues and pull requests welcome — especially reports of export footguns
+this plugin doesn't yet catch.
+
+## License
+
+[MIT](LICENSE)

data/lib/fastlane/plugin/godot/actions/godot_export_action.rb

@@ -0,0 +1,119 @@
+require 'fastlane/action'
+require 'shellwords'
+require_relative '../helper/godot_helper'
+
+module Fastlane
+  module Actions
+    class GodotExportAction < Action
+      def self.run(params)
+        godot = params[:godot_binary]
+        project_path = File.expand_path(params[:project_path])
+        preset_name = params[:preset]
+
+        UI.user_error!("No project.godot in #{project_path}") unless File.exist?(File.join(project_path, 'project.godot'))
+
+        version = Helper::GodotHelper.godot_version(godot)
+        UI.message("Godot #{version}")
+
+        cfg_path = File.join(project_path, 'export_presets.cfg')
+        preset = Helper::GodotHelper.find_preset(cfg_path, preset_name)
+        Helper::GodotHelper.verify_templates!(version, preset[:platform])
+
+        output_path = params[:output_path] || preset[:export_path]
+        UI.user_error!("Preset '#{preset_name}' has no export_path and no output_path was given") if output_path.nil? || output_path.empty?
+        absolute_output = File.expand_path(output_path, project_path)
+        FileUtils.mkdir_p(File.dirname(absolute_output))
+
+        if params[:import_first]
+          UI.message('Importing project resources (stale import caches abort exports)…')
+          Actions.sh("#{godot.shellescape} --headless --path #{project_path.shellescape} --import")
+        end
+
+        export_flag = params[:debug] ? '--export-debug' : '--export-release'
+        command = [
+          godot.shellescape,
+          '--headless',
+          '--path', project_path.shellescape,
+          export_flag, preset_name.shellescape,
+          absolute_output.shellescape
+        ]
+        command << '--verbose' if params[:verbose]
+
+        UI.message("Exporting preset '#{preset_name}' (#{preset[:platform]}) -> #{absolute_output}")
+        Actions.sh(command.join(' '))
+
+        # Godot has historically exited 0 on some export failures; trust the artifact, not the exit code.
+        UI.user_error!("Export claimed success but produced nothing at #{absolute_output}") unless File.exist?(absolute_output)
+
+        UI.success("Exported #{preset[:platform]} build: #{absolute_output}")
+        Actions.lane_context[SharedValues::GODOT_EXPORT_OUTPUT] = absolute_output
+        absolute_output
+      end
+
+      def self.description
+        'Export a Godot project headlessly using an export preset'
+      end
+
+      def self.return_value
+        'Absolute path to the exported artifact (for iOS, the generated Xcode project)'
+      end
+
+      def self.authors
+        ['Mad Science Software']
+      end
+
+      def self.output
+        [['GODOT_EXPORT_OUTPUT', 'Absolute path to the exported artifact']]
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :preset,
+                                       env_name: 'FL_GODOT_PRESET',
+                                       description: 'Name of the export preset in export_presets.cfg',
+                                       type: String),
+          FastlaneCore::ConfigItem.new(key: :project_path,
+                                       env_name: 'FL_GODOT_PROJECT_PATH',
+                                       description: 'Directory containing project.godot',
+                                       type: String,
+                                       default_value: '.'),
+          FastlaneCore::ConfigItem.new(key: :godot_binary,
+                                       env_name: 'FL_GODOT_BINARY',
+                                       description: 'Path to the Godot binary',
+                                       type: String,
+                                       default_value: 'godot'),
+          FastlaneCore::ConfigItem.new(key: :output_path,
+                                       env_name: 'FL_GODOT_OUTPUT_PATH',
+                                       description: 'Where to write the exported artifact (defaults to the preset export_path), relative to the project',
+                                       type: String,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :debug,
+                                       env_name: 'FL_GODOT_DEBUG',
+                                       description: 'Export a debug build instead of a release build',
+                                       type: Boolean,
+                                       default_value: false),
+          FastlaneCore::ConfigItem.new(key: :import_first,
+                                       env_name: 'FL_GODOT_IMPORT_FIRST',
+                                       description: 'Run a headless --import before exporting (a stale import cache aborts exports)',
+                                       type: Boolean,
+                                       default_value: true),
+          FastlaneCore::ConfigItem.new(key: :verbose,
+                                       env_name: 'FL_GODOT_VERBOSE',
+                                       description: 'Pass --verbose to Godot',
+                                       type: Boolean,
+                                       default_value: false)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+
+  module Actions
+    module SharedValues
+      GODOT_EXPORT_OUTPUT = :GODOT_EXPORT_OUTPUT
+    end
+  end
+end

data/lib/fastlane/plugin/godot/actions/godot_init_action.rb

@@ -0,0 +1,89 @@
+require 'fastlane/action'
+require_relative '../helper/godot_scaffold'
+
+module Fastlane
+  module Actions
+    class GodotInitAction < Action
+      def self.run(params)
+        project_path = File.expand_path(params[:project_path])
+        UI.user_error!("No project.godot in #{project_path} — run this from (or point project_path at) a Godot project") unless File.exist?(File.join(project_path, 'project.godot'))
+
+        created = []
+        skipped = []
+        write = lambda do |relative_path, content, binary: false|
+          target = File.join(project_path, relative_path)
+          if File.exist?(target)
+            skipped << relative_path
+          else
+            FileUtils.mkdir_p(File.dirname(target))
+            binary ? File.binwrite(target, content) : File.write(target, content)
+            created << relative_path
+          end
+        end
+
+        scaffold = Helper::GodotScaffold
+        write.call('Gemfile', scaffold::GEMFILE)
+        write.call('fastlane/Pluginfile', scaffold::PLUGINFILE)
+        write.call('fastlane/Appfile', scaffold::APPFILE)
+        write.call('fastlane/Fastfile', scaffold::FASTFILE)
+        write.call('fastlane/.env.template', scaffold::ENV_TEMPLATE)
+        write.call('export_presets.cfg', scaffold::EXPORT_PRESETS)
+        write.call('build/.gdignore', '')
+        write.call('app_icon.png', scaffold.placeholder_icon_png, binary: true) if params[:icon]
+
+        gitignore = File.join(project_path, '.gitignore')
+        if File.exist?(gitignore)
+          existing = File.read(gitignore)
+          missing = scaffold::GITIGNORE_ENTRIES.reject { |entry| existing.include?(entry) }
+          UI.important("Your .gitignore is missing: #{missing.join(', ')} — add them so credentials and build products stay out of git") unless missing.empty?
+          skipped << '.gitignore'
+        else
+          write.call('.gitignore', scaffold::GITIGNORE)
+        end
+
+        created.each { |path| UI.success("created #{path}") }
+        skipped.each { |path| UI.message("kept existing #{path}") }
+
+        unless created.empty?
+          UI.important('Placeholders to fill in before building:')
+          UI.important('  - fastlane/Appfile: bundle identifier and team ID')
+          UI.important('  - export_presets.cfg: bundle identifier, team ID, export_path names')
+          UI.important('  - copy fastlane/.env.template to fastlane/.env and add your App Store Connect API key')
+          UI.important('  - app_icon.png is an obvious placeholder — replace it before shipping') if params[:icon]
+        end
+        created
+      end
+
+      def self.description
+        'Scaffold the files a Godot project needs for fastlane mobile releases (never overwrites existing files)'
+      end
+
+      def self.return_value
+        'Array of relative paths that were created'
+      end
+
+      def self.authors
+        ['Mad Science Software']
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :project_path,
+                                       env_name: 'FL_GODOT_PROJECT_PATH',
+                                       description: 'Directory containing project.godot',
+                                       type: String,
+                                       default_value: '.'),
+          FastlaneCore::ConfigItem.new(key: :icon,
+                                       env_name: 'FL_GODOT_INIT_ICON',
+                                       description: 'Also create a placeholder 1024x1024 app_icon.png (iOS export fails without an icon)',
+                                       type: Boolean,
+                                       default_value: true)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        true
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/godot/helper/godot_helper.rb

@@ -0,0 +1,92 @@
+require 'fastlane_core/ui/ui'
+
+module Fastlane
+  UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
+
+  module Helper
+    class GodotHelper
+      # Full version string, e.g. "4.7.1.stable.official.a13da4feb"
+      def self.godot_version(godot_binary)
+        output = `#{godot_binary.shellescape} --version 2>/dev/null`.strip
+        UI.user_error!("Could not run '#{godot_binary} --version' — is Godot installed and on the PATH?") if output.empty?
+        output.lines.last.strip
+      end
+
+      # Export templates live in a directory named after the version's
+      # release segment: "4.7.1.stable.official.a13da4feb" -> "4.7.1.stable"
+      def self.template_directory_name(version_string)
+        match = version_string.match(/^(\d+\.\d+(?:\.\d+)?\.[a-z0-9]+)/)
+        UI.user_error!("Unrecognized Godot version string: '#{version_string}'") unless match
+        match[1]
+      end
+
+      def self.templates_root
+        if FastlaneCore::Helper.mac?
+          File.expand_path('~/Library/Application Support/Godot/export_templates')
+        else
+          File.expand_path('~/.local/share/godot/export_templates')
+        end
+      end
+
+      # Minimal parse of export_presets.cfg: the preset headers plus the
+      # name/platform/export_path lines that follow each one.
+      def self.parse_presets(cfg_path)
+        UI.user_error!("No export_presets.cfg found at #{cfg_path} — create an export preset first (Project > Export in the Godot editor, or commit one)") unless File.exist?(cfg_path)
+
+        presets = []
+        current = nil
+        File.foreach(cfg_path) do |line|
+          case line
+          when /^\[preset\.\d+\]\s*$/
+            current = {}
+            presets << current
+          when /^\[preset\.\d+\.options\]\s*$/
+            current = nil
+          when /^name="(.*)"\s*$/
+            current[:name] = Regexp.last_match(1) if current
+          when /^platform="(.*)"\s*$/
+            current[:platform] = Regexp.last_match(1) if current
+          when /^export_path="(.*)"\s*$/
+            current[:export_path] = Regexp.last_match(1) if current
+          end
+        end
+        presets
+      end
+
+      def self.find_preset(cfg_path, preset_name)
+        presets = parse_presets(cfg_path)
+        preset = presets.find { |p| p[:name] == preset_name }
+        unless preset
+          available = presets.map { |p| "'#{p[:name]}' (#{p[:platform]})" }.join(', ')
+          UI.user_error!("No export preset named '#{preset_name}' in #{cfg_path}. Available presets: #{available.empty? ? 'none' : available}")
+        end
+        preset
+      end
+
+      # The template archive each platform's export requires, keyed by the
+      # platform string Godot writes into export_presets.cfg.
+      PLATFORM_TEMPLATE_FILES = {
+        'iOS' => ['ios.zip'],
+        'Android' => ['android_debug.apk', 'android_release.apk', 'android_source.zip'],
+        'macOS' => ['macos.zip'],
+        'Web' => ['web_release.zip', 'web_debug.zip']
+      }.freeze
+
+      def self.verify_templates!(version_string, platform)
+        dir = File.join(templates_root, template_directory_name(version_string))
+        needed = PLATFORM_TEMPLATE_FILES[platform]
+        return if needed.nil? # platform we don't know how to check — let Godot decide
+
+        missing = needed.reject { |f| File.exist?(File.join(dir, f)) }
+        return if missing.empty?
+
+        UI.user_error!(
+          "Godot #{template_directory_name(version_string)} export templates for #{platform} " \
+          "are missing (#{missing.join(', ')} not found in #{dir}). " \
+          'Download the templates bundle from https://godotengine.org/download and install it, ' \
+          "or unzip the needed files from the .tpz archive into #{dir}"
+        )
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/godot/helper/godot_scaffold.rb

@@ -0,0 +1,181 @@
+require 'zlib'
+
+module Fastlane
+  module Helper
+    # File templates for godot_init. Placeholder values are ALL-CAPS or
+    # com.example so nothing accidentally ships as-is.
+    class GodotScaffold
+      GEMFILE = <<~RUBY.freeze
+        source 'https://rubygems.org'
+
+        gem 'fastlane'
+
+        plugins_path = File.join(File.dirname(__FILE__), 'fastlane', 'Pluginfile')
+        eval_gemfile(plugins_path) if File.exist?(plugins_path)
+      RUBY
+
+      PLUGINFILE = <<~RUBY.freeze
+        gem 'fastlane-plugin-godot'
+      RUBY
+
+      APPFILE = <<~RUBY.freeze
+        # Your game's bundle identifier (must match the export preset).
+        app_identifier('com.example.mygame')
+
+        # Your 10-character Apple Developer team ID.
+        team_id('YOURTEAMID')
+      RUBY
+
+      FASTFILE = <<~RUBY.freeze
+        default_platform(:ios)
+
+        platform :ios do
+          desc 'Export from Godot and build a signed .ipa'
+          lane :build do
+            app_store_connect_api_key(
+              key_id: ENV.fetch('ASC_KEY_ID'),
+              issuer_id: ENV.fetch('ASC_ISSUER_ID'),
+              key_filepath: File.expand_path(ENV.fetch('ASC_KEY_PATH'))
+            )
+
+            xcodeproj = godot_export(preset: 'iOS')
+
+            # Reuse-or-create the distribution certificate and App Store
+            # profile; classic (non-cloud) signing works with an App Manager
+            # App Store Connect API key.
+            get_certificates
+            get_provisioning_profile
+
+            build_app(
+              project: xcodeproj,
+              scheme: File.basename(xcodeproj, '.xcodeproj'),
+              output_directory: 'build/ios',
+              export_method: 'app-store',
+              export_options: {
+                signingStyle: 'manual',
+                signingCertificate: 'Apple Distribution',
+                provisioningProfiles: {
+                  CredentialsManager::AppfileConfig.try_fetch_value(:app_identifier) =>
+                    lane_context[SharedValues::SIGH_NAME]
+                }
+              },
+              # Works around godotengine/godot#110052 (Godot writes a
+              # distribution identity into an automatic-signing config).
+              xcargs: 'CODE_SIGN_IDENTITY="Apple Development" -allowProvisioningUpdates'
+            )
+          end
+
+          desc 'Build and upload to TestFlight'
+          lane :beta do
+            build
+            upload_to_testflight
+          end
+        end
+
+        platform :android do
+          desc 'Export a debug-signed APK'
+          lane :build do
+            godot_export(preset: 'Android', debug: true)
+          end
+        end
+      RUBY
+
+      ENV_TEMPLATE = <<~TEXT.freeze
+        # Copy to fastlane/.env and fill in — fastlane loads it automatically.
+        # Never commit the real .env; commit only this template.
+        ASC_KEY_ID=ABC123DEFG
+        ASC_ISSUER_ID=12345678-1234-1234-1234-123456789012
+        ASC_KEY_PATH=~/.appstoreconnect/AuthKey_ABC123DEFG.p8
+      TEXT
+
+      GITIGNORE = <<~TEXT.freeze
+        # fastlane: local credentials and build products
+        fastlane/.env
+        fastlane/report.xml
+        build/
+        vendor/
+        .bundle/
+      TEXT
+
+      GITIGNORE_ENTRIES = ['fastlane/.env', 'fastlane/report.xml', 'build/'].freeze
+
+      EXPORT_PRESETS = <<~TEXT.freeze
+        [preset.0]
+
+        name="iOS"
+        platform="iOS"
+        runnable=true
+        dedicated_server=false
+        custom_features=""
+        export_filter="all_resources"
+        include_filter=""
+        exclude_filter=""
+        export_path="build/ios/Game.xcodeproj"
+        script_export_mode=2
+
+        [preset.0.options]
+
+        application/app_store_team_id="YOURTEAMID"
+        application/bundle_identifier="com.example.mygame"
+        application/short_version="0.1.0"
+        application/version="1"
+        application/min_ios_version="15.0"
+        application/export_project_only=true
+        icons/icon_1024x1024="res://app_icon.png"
+        orientation/portrait=true
+        orientation/upside_down=false
+        orientation/landscape_left=false
+        orientation/landscape_right=false
+
+        [preset.1]
+
+        name="Android"
+        platform="Android"
+        runnable=true
+        dedicated_server=false
+        custom_features=""
+        export_filter="all_resources"
+        include_filter=""
+        exclude_filter=""
+        export_path="build/android/Game.apk"
+        script_export_mode=2
+
+        [preset.1.options]
+
+        gradle_build/use_gradle_build=false
+        architectures/arm64-v8a=true
+        version/code=1
+        version/name="0.1.0"
+        package/unique_name="com.example.mygame"
+        package/name=""
+        package/signed=true
+        launcher_icons/main_192x192="res://app_icon.png"
+        screen/immersive_mode=true
+      TEXT
+
+      # Minimal valid 1024x1024 opaque PNG (Apple rejects alpha in the
+      # marketing icon): flat two-tone placeholder, obviously temporary.
+      def self.placeholder_icon_png(size = 1024)
+        background = [40, 90, 100].pack('C3')
+        foreground = [235, 180, 70].pack('C3')
+        low = size / 4
+        high = 3 * size / 4
+        raw = +''.b
+        size.times do |y|
+          raw << "\x00".b
+          size.times do |x|
+            raw << (x >= low && x < high && y >= low && y < high ? foreground : background)
+          end
+        end
+        chunk = lambda do |tag, data|
+          [data.bytesize].pack('N') + tag + data + [Zlib.crc32(tag + data)].pack('N')
+        end
+        header = [size, size, 8, 2, 0, 0, 0].pack('NNC5')
+        "\x89PNG\r\n\x1a\n".b +
+          chunk.call('IHDR'.b, header) +
+          chunk.call('IDAT'.b, Zlib::Deflate.deflate(raw, Zlib::BEST_COMPRESSION)) +
+          chunk.call('IEND'.b, ''.b)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/godot/version.rb

@@ -0,0 +1,5 @@
+module Fastlane
+  module Godot
+    VERSION = '0.1.0'.freeze
+  end
+end

data/lib/fastlane/plugin/godot.rb

@@ -0,0 +1,15 @@
+require 'fastlane/plugin/godot/version'
+
+module Fastlane
+  module Godot
+    # Return all .rb files inside the "actions" and "helper" directories
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+# By default, fastlane loads all actions and helpers of a plugin at once
+Fastlane::Godot.all_classes.each do |current|
+  require current
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-godot
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mad Science Software
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: 'Godot-specific fastlane actions: headless engine exports, export template
+  verification, and Xcode project handling for shipping Godot games to the app stores.'
+email:
+- jamesyoungwrites@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/godot.rb
+- lib/fastlane/plugin/godot/actions/godot_export_action.rb
+- lib/fastlane/plugin/godot/actions/godot_init_action.rb
+- lib/fastlane/plugin/godot/helper/godot_helper.rb
+- lib/fastlane/plugin/godot/helper/godot_scaffold.rb
+- lib/fastlane/plugin/godot/version.rb
+homepage: https://github.com/Mad-Science-Software/fastlane-plugin-godot
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+  source_code_uri: https://github.com/Mad-Science-Software/fastlane-plugin-godot
+  changelog_uri: https://github.com/Mad-Science-Software/fastlane-plugin-godot/releases
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Export and ship Godot Engine games with fastlane
+test_files: []