crosspack 0.2.0

data/lib/crosspack/packer.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tmpdir'
+
+module Crosspack
+  # Single entry point: takes a compiled artifacts directory (per
+  # package.yaml), resolves dependencies for the target (per deps.yaml) and
+  # produces a native package under output_base/<family>/<version>/<arch>/.
+  # The builder is chosen by the target format — deb, rpm or PKGBUILD.
+  class Packer
+    def self.pack(manifest:, deps:, target:, version:, root: Dir.pwd,
+                  output_base: 'crosspacks')
+      new(manifest: manifest, deps: deps, target: target, version: version,
+          root: root, output_base: output_base).pack
+    end
+
+    def initialize(manifest:, deps:, target:, version:, root:, output_base:)
+      @pkg_path = manifest
+      @deps_path = deps
+      @target = target
+      @version = version.to_s
+      @root = root
+      @output_base = output_base
+    end
+
+    def pack
+      @pkg = PackageManifest.load(@pkg_path)
+      @deps = Manifest.load(@deps_path)
+      validate_both!
+      @pkg_data = build_layout
+
+      case @target.format
+      when :deb
+        pack_deb
+      when :rpm
+        pack_rpm
+      when :pkgbuild
+        pack_pkgbuild
+      when :winget
+        pack_windows
+      when :cask
+        pack_macos
+      else
+        raise BuildError,
+              "packing is not defined for target #{@target} (format #{@target.format})"
+      end
+    end
+
+    private
+
+    def validate_both!
+      errors = []
+      errors << @pkg.error_report unless @pkg.valid?
+      errors << @deps.error_report unless @deps.valid?
+      return if errors.empty?
+
+      raise InvalidManifestError, errors.join("\n")
+    end
+
+    # Layout shared by every format. The artifacts tree mirrors the output
+    # tree exactly — builds/<family>[/<version>]/<arch>/ — so the source
+    # directory for a target is computed the same way as its output dir.
+    # A Linux binary can never sneak into a Windows package: if the target's
+    # build directory is absent, packing fails.
+    def build_layout
+      src_dir = File.expand_path(@target.output_dir(@pkg.sources, @target.format), @root)
+      unless File.directory?(src_dir)
+        available = Builds.available(File.expand_path(@pkg.sources, @root))
+        hint = available.empty? ? 'no built targets at all.' :
+               "available builds: #{available.map { |t| "#{t} (#{t.output_dir(@pkg.sources, t.format)})" }.join(', ')}."
+        raise BuildError,
+              "No compiled artifacts for target #{@target}: expected them in #{src_dir}.\n" \
+              "The builds tree (#{@pkg.sources}) mirrors the output tree: builds/<family>/<version>/<arch>/. " \
+              "Currently #{hint}\n" \
+              'Build the application for this target first, then pack.'
+      end
+
+      lib_dst = File.join(@pkg.prefix, @pkg.lib_dir)
+      files = @pkg.payload.to_h { |n| [File.join(src_dir, n), File.join(lib_dst, n)] }
+
+      if @pkg.icon
+        icon_src = File.expand_path(@pkg.icon, @root)
+        raise BuildError, "icon: file not found #{icon_src}" unless File.file?(icon_src)
+
+        files[icon_src] = File.join(@pkg.prefix, 'share', 'pixmaps', "#{@pkg.name}.png")
+      end
+
+      if @pkg.desktop
+        files[desktop_entry_path] = File.join(@pkg.prefix, 'share', 'applications', "#{@pkg.name}.desktop")
+      end
+
+      symlinks = @pkg.links.to_h { |link, target| [File.join(@pkg.prefix, link), target] }
+      executables = @pkg.executables.map { |exe| File.join(lib_dst, exe) }
+
+      { files: files, symlinks: symlinks, executables: executables,
+        src_dir: src_dir, lib_dst: lib_dst }
+    end
+
+    # Writes the .desktop file next to other staging artifacts and returns
+    # its path (rooted under build/ so repeated runs reuse one location).
+    def desktop_entry_path
+      dir = File.join(@root, 'build', 'pkg')
+      FileUtils.mkdir_p(dir)
+      path = File.join(dir, "#{@pkg.name}.desktop")
+      d = @pkg.desktop
+      File.write(path, <<~DESKTOP)
+        [Desktop Entry]
+        Type=Application
+        Name=#{d['name'] || @pkg.name}
+        Comment=#{d['comment'] || @pkg.summary}
+        Exec=#{d['exec'] || @pkg.name}
+        Icon=#{@pkg.name}
+        Terminal=false
+        Categories=#{d['categories'] || 'Utility;'}
+      DESKTOP
+      path
+    end
+
+    def resolved_depends(format)
+      Resolver.new(@deps).depends(@target, format: format)
+    end
+
+    def pack_deb
+      output = File.join(@target.output_dir(@output_base, :deb),
+                         "#{@pkg.name}_#{@version}_#{@target.package_arch(:deb)}.deb")
+      Builders::Deb.build(
+        name: @pkg.name,
+        version: @version,
+        architecture: @target.package_arch(:deb),
+        maintainer: @pkg.maintainer,
+        description: @pkg.description,
+        depends: resolved_depends(:deb),
+        files: @pkg_data[:files],
+        symlinks: @pkg_data[:symlinks],
+        executables: @pkg_data[:executables],
+        section: @pkg.section,
+        output: output
+      )
+      output
+    end
+
+    def pack_rpm
+      version, release = split_version
+      output = File.join(@target.output_dir(@output_base, :rpm),
+                         "#{@pkg.name}-#{version}-#{release}.#{@target.package_arch(:rpm)}.rpm")
+      Builders::Rpm.build(
+        name: @pkg.name,
+        version: version,
+        release: release,
+        summary: @pkg.summary,
+        license: @pkg.license,
+        requires: resolved_depends(:rpm),
+        files: @pkg_data[:files],
+        symlinks: @pkg_data[:symlinks],
+        executables: @pkg_data[:executables],
+        description: @pkg.summary,
+        arch: @target.package_arch(:rpm),
+        output: output
+      )
+      output
+    end
+
+    def pack_pkgbuild
+      version, release = split_version
+      output = File.join(@target.output_dir(@output_base, :pkgbuild), 'PKGBUILD')
+      Builders::Pkgbuild.generate(
+        name: @pkg.name,
+        version: version,
+        release: release,
+        pkgdesc: @pkg.summary,
+        maintainer: @pkg.maintainer,
+        depends: resolved_depends(:pkgbuild),
+        arch: [@target.package_arch(:pkgbuild)],
+        # PKGBUILD sources are archive-relative names, not local paths.
+        files: @pkg.payload.to_h { |n| [n, File.join(@pkg_data[:lib_dst], n)] },
+        symlinks: @pkg_data[:symlinks],
+        executables: @pkg_data[:executables],
+        source: ["#{@pkg.name}-#{version}.tar.gz"],
+        license: @pkg.license,
+        output: output
+      )
+      output
+    end
+
+    def split_version
+      parts = @version.split('-', 2)
+      parts << '1' if parts.size == 1
+      parts
+    end
+
+    # Windows: flat payload under Program Files/<name>/ via WiX. Unix symlinks
+    # do not apply; everything from `sources` goes in as regular files.
+    def pack_windows
+      output = File.join(@target.output_dir(@output_base, :winget),
+                         "#{@pkg.name}-#{Builders::Wix.msi_version(@version)}.msi")
+      files = @pkg.payload.to_h { |n| [File.join(@pkg_data[:src_dir], n), n] }
+      Builders::Wix.build(
+        name: @pkg.name,
+        version: @version,
+        manufacturer: @pkg.maintainer,
+        summary: @pkg.summary,
+        files: files,
+        arch: @target.package_arch(:winget),
+        output: output
+      )
+    end
+
+    # macOS: .app bundle staging; DMG itself requires a Mac (hdiutil).
+    def pack_macos
+      output_dir = @target.output_dir(@output_base, :cask)
+      files = @pkg.payload.to_h { |n| [File.join(@pkg_data[:src_dir], n), n] }
+      Builders::AppDir.build(
+        name: @pkg.name,
+        version: @version,
+        summary: @pkg.summary,
+        files: files,
+        executables: @pkg.executables,
+        output: output_dir
+      )
+    end
+  end
+end

data/lib/crosspack/resolver.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Crosspack
+  # Result of resolving one canonical dependency for one target.
+  # verdict: :packages — concrete names in `names` (ordered alternatives);
+  #          :system / :none / :bundled — nothing to install.
+  class Resolution
+    attr_reader :canonical, :verdict, :names
+
+    def initialize(canonical, verdict, names = [])
+      @canonical = canonical
+      @verdict = verdict
+      @names = names
+    end
+
+    def packages?
+      @verdict == :packages
+    end
+
+    def to_s
+      packages? ? @names.join(' | ') : @verdict.to_s
+    end
+  end
+
+  class ResolveError < StandardError; end
+
+  # Turns (manifest, target) into concrete package dependencies. No network,
+  # no search: everything comes from deps.yaml.
+  class Resolver
+    def initialize(manifest)
+      @manifest = manifest
+      @manifest.validate!
+    end
+
+    # Returns [Resolution] for every canonical name in the manifest.
+    def resolve(target)
+      family = target.family.to_s
+      @manifest.deps.map do |name, body|
+        rules = body['targets']
+        rule = rules[family]
+        if rule.nil?
+          available = rules.keys.map(&:to_s).join(', ')
+          raise ResolveError,
+                "#{name}: deps.yaml has no rules for family #{family} (target #{target}). " \
+                "Add the section #{name}: targets: #{family}: ... — currently described: #{available}"
+        end
+
+        value = resolve_rule(name, rule, target, family)
+        if value.is_a?(Array)
+          Resolution.new(name, :packages, value)
+        else
+          Resolution.new(name, value.to_sym)
+        end
+      end
+    end
+
+    # Dependencies rendered for a package format:
+    #   :deb      -> "pkg-a | pkg-b, pkg-c" (Depends: line)
+    #   :rpm      -> ["pkg-a", "pkg-c"]     (first alternative wins)
+    #   :pkgbuild -> same as rpm
+    def depends(target, format: target.format)
+      packages = resolve(target).select(&:packages?)
+      case format
+      when :deb
+        packages.map { |r| r.names.join(' | ') }.join(', ')
+      when :rpm, :pkgbuild, :cask, :winget
+        packages.map { |r| r.names.first }
+      else
+        raise ArgumentError, "unknown format #{format.inspect} (allowed: :deb, :rpm, :pkgbuild)"
+      end
+    end
+
+    private
+
+    def resolve_rule(name, rule, target, family)
+      return rule if rule.is_a?(String) # whole-family verdict
+
+      key = target.version || '*'
+      return rule[key] if rule.key?(key)
+
+      fallback = rule['*']
+      return fallback unless fallback.nil?
+
+      versions = rule.keys.map { |v| v == '*' ? '"*" (any)' : v.inspect }.join(', ')
+      raise ResolveError,
+            "#{name}: no rules for #{family} #{target.version.inspect} and no \"*\" key. " \
+            "Versions described in the file: #{versions}. Add targets.#{family}.\"#{target.version}\" " \
+            'or a "*" wildcard rule'
+    end
+  end
+end

data/lib/crosspack/target.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Crosspack
+  # A build target: distro family + optional version + CPU architecture.
+  # Parsed from strings like "debian-12", "ubuntu-24.04", "fedora-41", "arch".
+  class Target
+    FAMILIES = %i[debian ubuntu fedora almalinux rocky opensuse arch macos windows].freeze
+    VERSIONLESS_FAMILIES = %i[arch].freeze
+    # Version is allowed but not required (macos-15, windows-11.0, or bare).
+    OPTIONAL_VERSION_FAMILIES = %i[macos windows].freeze
+    FORMAT_BY_FAMILY = {
+      debian: :deb, ubuntu: :deb,
+      fedora: :rpm, almalinux: :rpm, rocky: :rpm, opensuse: :rpm,
+      arch: :pkgbuild, macos: :cask, windows: :winget
+    }.freeze
+
+    class Error < StandardError; end
+
+    attr_reader :family, :version, :arch
+
+    # Normalizes common architecture spellings: amd64/x64 -> x86_64,
+    # aarch64 -> arm64.
+    ARCH_ALIASES = {
+      amd64: :x86_64, 'x64': :x86_64, x86_64: :x86_64, x86: nil,
+      arm64: :arm64, aarch64: :arm64, armhf: nil
+    }.freeze
+
+    def self.normalize_arch(value)
+      norm = value.to_s.strip.downcase.sub(/\Ax86-64\z/, 'x86_64').to_sym
+      ARCH_ALIASES.fetch(norm, norm)
+    end
+
+    def self.parse(str, arch: :x86_64)
+      s = str.to_s.strip
+      raise Error, 'target string is empty' if s.empty?
+
+      family, version = s.split('-', 2)
+      family_sym = family.to_sym
+      unless FAMILIES.include?(family_sym)
+        raise Error, "unknown distro family #{family.inspect}; allowed: #{FAMILIES.join(', ')}"
+      end
+
+      norm_arch = normalize_arch(arch)
+      raise Error, "unsupported architecture #{arch.inspect} (supported: x86_64/amd64, arm64/aarch64)" if norm_arch.nil?
+
+      if VERSIONLESS_FAMILIES.include?(family_sym) && version
+        raise Error, "family #{family} does not use a version (remove \"-#{version}\")"
+      end
+      version_required = !VERSIONLESS_FAMILIES.include?(family_sym) &&
+                         !OPTIONAL_VERSION_FAMILIES.include?(family_sym)
+      if version_required && version.to_s.strip.empty?
+        raise Error, "specify a version for family #{family}, e.g. #{family}-12"
+      end
+
+      new(family_sym, version, norm_arch)
+    end
+
+    def initialize(family, version = nil, arch = :x86_64)
+      @family = family.to_sym
+      @version = version && version.to_s
+      @arch = arch
+    end
+
+    def format
+      FORMAT_BY_FAMILY.fetch(@family)
+    end
+
+    # Per-format architecture spelling: deb uses amd64/arm64, rpm and
+    # PKGBUILD use x86_64/aarch64.
+    def package_arch(format = self.format)
+      return 'amd64' if format == :deb && @arch == :x86_64
+      return 'arm64' if format == :deb && @arch == :arm64
+      return 'aarch64' if @arch == :arm64
+
+      'x86_64'
+    end
+
+    def to_s
+      @version ? "#{@family}-#{@version}" : @family.to_s
+    end
+    alias inspect to_s
+
+    # Output layout for build artifacts: base/<family>[/<version>]/<arch>,
+    # e.g. crosspacks/ubuntu/24.04/amd64, crosspacks/windows/11.0/x86_64.
+    # Families without a version (arch, or bare macos/windows) skip the segment.
+    def output_dir(base, format = self.format)
+      parts = [base.to_s, @family.to_s]
+      parts << @version if @version
+      parts << package_arch(format)
+      File.join(*parts)
+    end
+  end
+end

data/lib/crosspack/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Crosspack
+  VERSION = '0.2.0'
+end

data/lib/crosspack.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'crosspack/version'
+require_relative 'crosspack/target'
+require_relative 'crosspack/manifest'
+require_relative 'crosspack/package_manifest'
+require_relative 'crosspack/resolver'
+require_relative 'crosspack/matrix'
+require_relative 'crosspack/builds'
+require_relative 'crosspack/packer'
+require_relative 'crosspack/builders/deb'
+require_relative 'crosspack/builders/rpm'
+require_relative 'crosspack/builders/pkgbuild'
+require_relative 'crosspack/builders/wix'
+require_relative 'crosspack/builders/app_dir'
+
+module Crosspack
+  BUILDERS = {
+    deb: Builders::Deb,
+    rpm: Builders::Rpm,
+    pkgbuild: Builders::Pkgbuild,
+    winget: Builders::Wix,
+    cask: Builders::AppDir
+  }.freeze
+
+  # Shared options for all builders, expressed once so every format stages
+  # the same file tree:
+  #   files:       { source_path => destination_inside_package (no leading /) }
+  #   symlinks:    { link_path_inside_package => link_target }
+  #   executables: [destination paths to chmod 0755]
+  class BuildError < StandardError; end
+
+  # Convenience wrapper: Crosspack.pack(manifest: 'package.yaml',
+  # deps: 'deps.yaml', target: Target.parse('debian-12'), version: '1.0-1')
+  def self.pack(**kwargs)
+    Packer.pack(**kwargs)
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: crosspack
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Oleg Orlov
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-09-08 00:00:00.000000000 Z
+dependencies: []
+description: 'Two cooperating commands: crossbuild runs the build steps of a project
+  from a build.yaml matrix and fans the produced artifacts out into the per-target
+  builds/ tree; crosspack turns that tree into native packages, driven by a cross-distro
+  deps.yaml. Both share the same target vocabulary so the trees never drift apart.'
+email:
+- orelcokolov@gmail.com
+executables:
+- crosspack
+- crossbuild
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- exe/crossbuild
+- exe/crosspack
+- lib/crossbuild.rb
+- lib/crossbuild/build_manifest.rb
+- lib/crossbuild/builder.rb
+- lib/crossbuild/distributor.rb
+- lib/crossbuild/matrix.rb
+- lib/crossbuild/platform.rb
+- lib/crossbuild/runner.rb
+- lib/crossbuild/version.rb
+- lib/crossbuild/version_scheme.rb
+- lib/crosspack.rb
+- lib/crosspack/builders/app_dir.rb
+- lib/crosspack/builders/deb.rb
+- lib/crosspack/builders/pkgbuild.rb
+- lib/crosspack/builders/rpm.rb
+- lib/crosspack/builders/wix.rb
+- lib/crosspack/builds.rb
+- lib/crosspack/manifest.rb
+- lib/crosspack/matrix.rb
+- lib/crosspack/package_manifest.rb
+- lib/crosspack/packer.rb
+- lib/crosspack/resolver.rb
+- lib/crosspack/target.rb
+- lib/crosspack/version.rb
+homepage: https://github.com/OrelSokolov/crosspack
+licenses:
+- Nonstandard
+metadata:
+  source_code_uri: https://github.com/OrelSokolov/crosspack
+  changelog_uri: https://github.com/OrelSokolov/crosspack/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Cross-platform build orchestrator and native package builder (deb/rpm/PKGBUILD/winget/cask)
+test_files: []