crosspack 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cb2e2fb91b4f2215649e739ff6ec7128a11e06abe8d776f870d686261439a974
+  data.tar.gz: 3b17f1325d46d5147a0d87fee2d62ee2cb021f4a11c4ab16cf54a94562d843ad
+SHA512:
+  metadata.gz: 19cfe0db0863bff0e3b69d39ccefd0066ae99a85586ae8cabe19951897f0852b70966cc39372740a9a7e779ad36c81827797094befe8e292c7f420d1a17a0578
+  data.tar.gz: 9b220eff4186f4f1f88875d0b802c0d7a76f1b5d394e0ec828706a2e56d71676f809c1726de82e39f950ad323056b73104c9022c9fa181f554830817748dd612

data/CHANGELOG.md

@@ -0,0 +1,36 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.2.0] - 2026-09-08
+
+### Added
+- Merged the `crossbuild` gem into `crosspack`: one gem, two commands.
+  `crossbuild build` runs `build.yaml` matrix steps on the host and fans
+  artifacts out into `builds/<family>[/<version>]/<arch>/`; `crosspack pack`
+  packages that tree as before.
+- `build.yaml` manifest with schema validation, version schemes
+  (`calver` / `git-tag` / `env:VAR` / literal), `{{version}}`-style
+  placeholder expansion and `CROSSBUILD_*` environment facts.
+- crossbuild CLI: `validate`, `matrix`, `version`, `build`, `targets`.
+- Library API: `Crossbuild.build` plus public `BuildManifest`,
+  `VersionScheme`, `Runner`, `Distributor`, `Matrix`, `Builder`, `Platform`.
+
+## [0.1.0] - 2026-09-08
+
+### Added
+- `package.yaml` / `deps.yaml` manifests with embedded schema validation and
+  path-pointing error messages.
+- Dependency resolution per distro family/version (`Resolver`), dependency ×
+  target matrix rendering (`Matrix`).
+- Builders: deb (`dpkg-deb`), rpm (`rpmbuild`), PKGBUILD, WiX sources (`.wxs`),
+  macOS app bundle staging.
+- CLI: `validate`, `resolve`, `matrix`, `pack`, `targets`.
+- Library API: `Crosspack.pack` plus public `PackageManifest`, `Manifest`,
+  `Resolver`, `Matrix`, `Target`, `Builders::*`.
+
+[0.2.0]: https://github.com/OrelSokolov/crosspack/releases/tag/v0.2.0
+[0.1.0]: https://github.com/OrelSokolov/crosspack/releases/tag/v0.1.0

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2026 Oleg Orlov
+
+All rights reserved.
+
+This software and its source code are proprietary and confidential.
+No part of this software may be copied, modified, distributed, sublicensed,
+or sold without the prior written permission of the copyright holder.
+
+This software is provided by the copyright holder "as is" and any express
+or implied warranties, including, but not limited to, the implied warranties
+of merchantability and fitness for a particular purpose are disclaimed.
+In no event shall the copyright holder be liable for any direct, indirect,
+incidental, special, exemplary, or consequential damages (including, but
+not limited to, procurement of substitute goods or services; loss of use,
+data, or profits; or business interruption) however caused and on any theory
+of liability, whether in contract, strict liability, or tort (including
+negligence or otherwise) arising in any way out of the use of this software,
+even if advised of the possibility of such damage.

data/README.md

@@ -0,0 +1,192 @@
+# crosspack
+
+Cross-platform build **and** pack toolchain for Wails-style desktop apps,
+shipped as one gem with two cooperating commands:
+
+- **`crossbuild`** — runs the build steps of a project from a small
+  `build.yaml` matrix and fans the produced artifacts out into the
+  per-target tree `builds/<family>[/<version>]/<arch>/`.
+- **`crosspack`** — turns that compiled tree into native packages
+  (deb / rpm / PKGBUILD / WiX / app bundle) for any target
+  distro × version × arch, driven by two small manifests.
+
+The two commands share the same target vocabulary (`Crosspack::Target`),
+so the build tree and the pack tree never drift apart. Build and pack
+stay cleanly separated: `crossbuild` never packages, `crosspack` never
+compiles — feed the output of one straight into the other:
+
+```
+crossbuild build                          # builds/ tree
+crosspack pack --target debian-12 --version 2026.08.31-33837
+```
+
+## crossbuild: build.yaml
+
+```yaml
+name: myapp
+version: calver            # calver | git-tag | env:VAR | any literal string
+output: builds             # default builds; mirrors package.yaml `sources`
+
+matrix:
+  - build: linux/amd64     # os/arch this entry builds on (arch may be "any")
+    env:                   # extra env for the steps of this entry
+      CGO_ENABLED: "1"
+    steps:                 # shell commands, run from the project root
+      - wails build -platform linux/amd64 -ldflags "-X myapp/internal/app.appVersion={{version}}"
+      - cargo build --release -p helper --locked
+    artifacts:
+      from: build/bin      # what got built
+      include: [myapp, helper, "*.onnx", "*.so*"]   # default: ["*"]
+      to: [ubuntu-22.04, ubuntu-24.04, debian-12, debian-13]
+      mode: symlink        # symlink | copy, default symlink
+
+  - id: windows            # defaults to the build platform string
+    build: windows/amd64
+    steps:
+      - wails build -platform windows/amd64 -ldflags "-X ...={{version}}"
+    artifacts:
+      from: build/bin
+      include: [myapp.exe]
+      to: [windows-11.0]
+```
+
+Placeholders `{{version}}`, `{{name}}`, `{{platform}}`, `{{os}}`, `{{arch}}`
+and `{{id}}` are expanded by the gem itself (works the same under POSIX
+shells and cmd.exe); the same facts are exported as `CROSSBUILD_VERSION`,
+`CROSSBUILD_NAME`, ... environment variables. Steps may freely call existing
+rake tasks (`rake build:prepare`) or helper scripts.
+
+Artifacts land in the shared layout, e.g.:
+
+```
+builds/ubuntu/24.04/amd64/myapp -> build/bin/myapp   (symlink)
+builds/windows/11.0/x86_64/myapp.exe
+```
+
+### Version schemes
+
+| scheme        | value                                                      |
+|---------------|------------------------------------------------------------|
+| `calver`      | `YYYY.MM.DD-<secs since local midnight>`, e.g. `2026.08.31-33837` (default) |
+| `git-tag`     | latest `git describe --tags --abbrev=0`, fallback `0.0.0-dev` |
+| `env:VAR`     | taken from `VAR`; build fails loudly when unset            |
+| other string  | used verbatim, e.g. `version: 1.2.3`                       |
+
+### crossbuild CLI
+
+```
+crossbuild validate                       # build.yaml against the schema
+crossbuild matrix                         # entries × host buildability table
+crossbuild version                        # computed version
+crossbuild build [--target linux/amd64]   # all host-buildable entries, or one
+crossbuild targets                        # what is in builds/ ready to pack
+```
+
+`build` refuses invalid manifests with path-pointing errors, runs only the
+entries whose `build:` platform matches the host, then distributes.
+
+## crosspack: two manifests
+
+**`package.yaml`** — what and how to pack:
+
+```yaml
+name: myapp
+maintainer: Your Name <you@example.com>
+summary: MyApp - cross-platform desktop application   # optional
+description: |-
+  MyApp - cross-platform desktop application.
+  Bundles helper binaries and model assets alongside the GUI...
+license: Proprietary       # optional, default Proprietary
+section: utils             # optional, deb only
+
+sources: builds             # compiled artifacts tree written by crossbuild:
+                            # builds/<family>/<version>/<arch>/ — pack without
+                            # a matching build directory fails honestly
+prefix: usr/local          # install prefix inside the package
+lib_dir: lib/myapp       # optional, default lib/<name>
+
+payload:                   # files from sources -> <prefix>/<lib_dir>/
+  - myapp
+  - helper
+  - model.onnx
+
+executables: [myapp, helper]     # chmod 755, must be in payload
+
+links:                     # symlinks relative to prefix
+  bin/myapp: ../lib/myapp/myapp
+
+desktop:                   # optional, .desktop generated
+  name: MyApp
+  comment: Cross-platform desktop application
+  categories: Utility;Audio
+
+icon: build/appicon.png    # optional, -> <prefix>/share/pixmaps/<name>.png
+```
+
+**`deps.yaml`** — canonical dependency names resolved to concrete packages
+per distro family/version (see the file itself for the full schema):
+
+```yaml
+webkit2gtk:
+  targets:
+    debian:
+      "12": [libwebkit2gtk-4.1-0, libwebkit2gtk-4.0-37]  # deb: a | b
+    fedora: { "*": [webkit2gtk4.1] }
+    macos: system      # OS component
+    windows: system    # preinstalled (WebView2)
+```
+
+Both files are validated against embedded schemas with actionable,
+path-pointing error messages; every builder refuses to run on an invalid
+manifest.
+
+## CLI
+
+```
+crosspack validate                       # both package.yaml and deps.yaml
+crosspack resolve --target debian-12     # Depends line for the target
+crosspack matrix                         # dependency x target table
+crosspack pack --target debian-12 --version 2026.08.31-1234 [--root .]
+```
+
+`pack` picks the builder from the target and writes to
+`crosspacks/<family>/<version>/<arch>/`:
+
+```
+crosspacks/ubuntu/26.04/amd64/myapp_2026.08.31-1234_amd64.deb
+crosspacks/fedora/41/x86_64/myapp-2026.08.31-1234.x86_64.rpm   (needs rpmbuild)
+crosspacks/arch/x86_64/PKGBUILD
+```
+
+## Library
+
+```ruby
+require 'crosspack'   # pulls in Crossbuild too
+
+Crossbuild.build('build.yaml', root: Dir.pwd)            # all host entries
+Crossbuild.build('build.yaml', entry_id: 'windows')      # one entry explicitly
+
+Crosspack.pack(
+  manifest: 'package.yaml', deps: 'deps.yaml',
+  target: Crosspack::Target.parse('debian-12', arch: 'amd64'),
+  version: '2026.08.31-1234',
+  root: Dir.pwd, output_base: 'crosspacks'
+)
+```
+
+Lower-level pieces are public too: on the build side `Crossbuild::
+BuildManifest`, `VersionScheme`, `Runner`, `Distributor`, `Matrix`,
+`Builder`, `Platform`; on the pack side `Crosspack::PackageManifest`,
+`Manifest`, `Resolver`, `Matrix`, `Target`, `Builders::*`.
+
+Deb needs `dpkg-deb` (present on any Debian/Ubuntu), rpm needs
+`rpmbuild` (`sudo apt install rpm`), PKGBUILD generation needs nothing.
+The WiX builder generates `.wxs` sources (run the WiX Toolset yourself to
+get an MSI), the macOS builder stages the `.app` bundle (signing, notarization
+and .dmg creation are out of scope). Requires Ruby >= 3.2.
+
+## Tests
+
+```
+cd crosspack && rake test
+```

data/exe/crossbuild

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'optparse'
+
+begin
+  require 'crossbuild'
+rescue LoadError
+  require_relative '../lib/crossbuild'
+end
+
+def abort_with(message)
+  warn message
+  exit 1
+end
+
+options = { file: 'build.yaml', root: Dir.pwd, target: nil, version: nil, output_base: nil }
+parser = OptionParser.new do |opts|
+  opts.banner = "crossbuild #{Crossbuild::VERSION} — cross-platform build orchestrator\n" \
+                "Usage: crossbuild <command> [options]\n" \
+                'Commands: validate, matrix, version, build, targets'
+
+  opts.on('-f', '--file PATH', 'path to build.yaml (default: ./build.yaml)') { |v| options[:file] = v }
+  opts.on('--target ID', 'matrix entry to build, e.g. linux/amd64 (default: every host-buildable entry)') { |v| options[:target] = v }
+  opts.on('--version VERSION', 'override the version scheme for build') { |v| options[:version] = v }
+  opts.on('--root PATH', 'project root for relative paths (default: .)') { |v| options[:root] = v }
+  opts.on('--output-base DIR', 'output directory (default: the manifest output, builds)') { |v| options[:output_base] = v }
+  opts.on('-h', '--help', 'show help') do
+    puts opts
+    exit
+  end
+end
+parser.parse!
+
+command = ARGV.shift
+abort_with 'No command given. See: crossbuild --help' if command.nil?
+
+# Positional file path: crossbuild validate path/to/build.yaml
+options[:file] = ARGV.shift if ARGV.first && !ARGV.first.start_with?('-')
+
+file = File.expand_path(options[:file], options[:root])
+begin
+  manifest = Crossbuild::BuildManifest.load(file)
+rescue Crossbuild::InvalidManifestError => e
+  abort_with e.message
+end
+
+case command
+when 'validate'
+  puts manifest.error_report
+  exit(manifest.valid? ? 0 : 1)
+when 'matrix'
+  abort_with 'Schema is invalid — the matrix cannot be rendered. Run: crossbuild validate' unless manifest.valid?
+  puts Crossbuild::Matrix.new(manifest).render
+when 'version'
+  abort_with 'Schema is invalid. Run: crossbuild validate' unless manifest.valid?
+  begin
+    puts Crossbuild::VersionScheme.new(manifest.version).compute(root: options[:root])
+  rescue Crossbuild::VersionScheme::Error => e
+    abort_with e.message
+  end
+when 'build'
+  begin
+    result = Crossbuild::Builder.new(manifest, root: options[:root], output_base: options[:output_base],
+                                     version: options[:version]).run(entry_id: options[:target])
+  rescue Crossbuild::Error, Crosspack::InvalidManifestError => e
+    abort_with e.message
+  end
+  puts "\n📦 #{result.entries.size} entr#{result.entries.size == 1 ? 'y' : 'ies'} built, version #{result.version}"
+  puts 'Pack with: crosspack pack --target <target> --version ' + result.version
+when 'targets'
+  base = options[:output_base] || manifest.output
+  puts Crosspack::Builds.report(File.expand_path(base, options[:root]))
+else
+  abort_with "Unknown command #{command.inspect}. Available: validate, matrix, version, build, targets"
+end

data/exe/crosspack

@@ -0,0 +1,119 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'optparse'
+
+begin
+  require 'crosspack'
+rescue LoadError
+  require_relative '../lib/crosspack'
+end
+
+def abort_with(message)
+  warn message
+  exit 1
+end
+
+options = { file: 'deps.yaml', package: 'package.yaml', arch: 'amd64', format: nil,
+            version: nil, root: Dir.pwd, output_base: 'crosspacks' }
+parser = OptionParser.new do |opts|
+  opts.banner = "crosspack #{Crosspack::VERSION} — native package packer (deb/rpm/PKGBUILD/MSI/app)\n" \
+                "Usage: crosspack <command> [options]\n" \
+                'Commands: validate, resolve, matrix, pack, targets'
+
+  opts.on('-f', '--file PATH', 'path to deps.yaml (default: ./deps.yaml)') { |v| options[:file] = v }
+  opts.on('--package PATH', 'path to package.yaml (default: ./package.yaml)') { |v| options[:package] = v }
+  opts.on('--target TARGET', 'target: debian-12, ubuntu-24.04, fedora-41, arch, macos, windows') { |v| options[:target] = v }
+  opts.on('--arch ARCH', 'architecture: amd64/x86_64, arm64/aarch64 (default: amd64)') { |v| options[:arch] = v }
+  opts.on('--format FORMAT', 'output format for resolve: deb, rpm, pkgbuild (default: derived from the target)') { |v| options[:format] = v.to_sym }
+  opts.on('--version VERSION', 'package version for pack (required for pack)') { |v| options[:version] = v }
+  opts.on('--root PATH', 'project root for relative paths (default: .)') { |v| options[:root] = v }
+  opts.on('--output-base DIR', 'output directory (default: ./crosspacks)') { |v| options[:output_base] = v }
+  opts.on('-h', '--help', 'show help') do
+    puts opts
+    exit
+  end
+end
+begin
+  parser.parse!
+rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
+  abort_with "#{e.message}\nSee: crosspack --help"
+end
+
+command = ARGV.shift
+abort_with 'No command given. See: crosspack --help' if command.nil?
+
+# Positional file path: crosspack validate path/to/deps.yaml
+options[:file] = ARGV.shift if ARGV.first && !ARGV.first.start_with?('-')
+
+begin
+  manifest = Crosspack::Manifest.load(options[:file])
+rescue Crosspack::InvalidManifestError => e
+  abort_with e.message
+end
+
+case command
+when 'validate'
+  begin
+    pkg = Crosspack::PackageManifest.load(options[:package])
+  rescue Crosspack::InvalidManifestError => e
+    abort_with e.message
+  end
+  puts manifest.error_report
+  puts pkg.error_report
+  exit(manifest.valid? && pkg.valid? ? 0 : 1)
+when 'matrix'
+  abort_with 'Schema is invalid — the matrix cannot be built. Run: crosspack validate' unless manifest.valid?
+  puts Crosspack::Matrix.new(manifest).render
+when 'resolve'
+  abort_with 'Specify a target: --target debian-12 (see crosspack --help)' unless options[:target]
+  begin
+    target = Crosspack::Target.parse(options[:target], arch: options[:arch])
+  rescue Crosspack::Target::Error => e
+    abort_with "Invalid target #{options[:target].inspect}: #{e.message}"
+  end
+  begin
+    resolver = Crosspack::Resolver.new(manifest)
+    format = options[:format] || target.format
+    result = resolver.depends(target, format: format)
+    if result.is_a?(Array)
+      puts "# #{target} (#{format})"
+      result.each { |d| puts d }
+    else
+      puts "# #{target} (#{format})"
+      puts "Depends: #{result}"
+    end
+  rescue Crosspack::ResolveError => e
+    abort_with "Failed to resolve dependencies for #{target}:\n  #{e.message}"
+  end
+when 'pack'
+  abort_with 'Specify a target: --target debian-12 and a version: --version 1.0-1' unless options[:target] && options[:version]
+  begin
+    target = Crosspack::Target.parse(options[:target], arch: options[:arch])
+    path = Crosspack.pack(
+      manifest: options[:package],
+      deps: options[:file],
+      target: target,
+      version: options[:version],
+      root: options[:root],
+      output_base: options[:output_base]
+    )
+  rescue Crosspack::Target::Error => e
+    abort_with "Invalid target #{options[:target].inspect}: #{e.message}"
+  rescue Crosspack::InvalidManifestError, Crosspack::ResolveError, Crosspack::BuildError => e
+    abort_with e.message
+  end
+  puts "📦 #{path}"
+when 'targets'
+  # What can actually be packed: builds tree + resolvable deps per target.
+  pkg_path = File.expand_path(options[:package], options[:root])
+  sources = begin
+    Crosspack::PackageManifest.load(pkg_path).sources
+  rescue Crosspack::InvalidManifestError
+    nil
+  end
+  root = sources ? File.expand_path(sources, options[:root]) : File.join(options[:root], 'builds')
+  puts Crosspack::Builds.report(root)
+else
+  abort_with "Unknown command #{command.inspect}. Available: validate, resolve, matrix, pack, targets"
+end