crosspack 0.2.0

data/lib/crosspack/manifest.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Crosspack
+  # Canonical dependency names crosspack knows about. Anything else in
+  # deps.yaml still resolves, but produces a warning (possible typo).
+  KNOWN_CANONICAL = %w[
+    webkit2gtk gtk3 openmp ayatana-appindicator
+    glib2 cairo pango gdk-pixbuf alsa-lib pulseaudio dbus
+  ].freeze
+
+  # Scalar verdicts a target may carry instead of a package list.
+  VERDICTS = %w[system none bundled].freeze
+
+  CANONICAL_NAME_RE = /\A[a-z0-9][a-z0-9+._-]*\z/.freeze
+
+  # A single schema problem: full path into deps.yaml + human explanation.
+  class Issue
+    attr_reader :path, :message
+
+    def initialize(path, message)
+      @path = path
+      @message = message
+    end
+
+    def to_s
+      "#{@path}: #{@message}"
+    end
+  end
+
+  class InvalidManifestError < StandardError; end
+
+  # Parses and validates deps.yaml. Root keys are canonical dependency
+  # names; each maps to { targets: { family: { "version": [pkgs] } } } or a
+  # scalar verdict for a whole family.
+  class Manifest
+    attr_reader :path, :deps, :errors, :warnings
+
+    def self.load(path)
+      unless File.file?(path)
+        raise InvalidManifestError,
+              "Dependencies file not found: #{path}\n" \
+              'Create deps.yaml next to the Rakefile (see crosspack/README.md).'
+      end
+      begin
+        raw = YAML.safe_load(File.read(path), permitted_classes: [], aliases: false)
+      rescue Psych::SyntaxError => e
+        raise InvalidManifestError,
+              "#{path}: YAML syntax error on line #{e.line}: #{e.problem}"
+      end
+      new(path, raw)
+    end
+
+    def initialize(path, raw)
+      @path = path
+      @deps = raw.is_a?(Hash) ? raw : {}
+      @raw = raw
+      @errors = []
+      @warnings = []
+      validate
+    end
+
+    def valid?
+      @errors.empty?
+    end
+
+    # Raises with the full, formatted list of problems.
+    def validate!
+      return self if valid?
+
+      lines = ["#{path}: deps.yaml schema is invalid (#{@errors.size} errors):"]
+      @errors.each { |e| lines << "  ✗ #{e}" }
+      lines << 'Build aborted: fix the listed nodes and retry.'
+      raise InvalidManifestError, lines.join("\n")
+    end
+
+    # Report used by rake abort: errors (if any) plus warnings.
+    def error_report
+      lines = []
+      if valid?
+        lines << "#{path}: schema is valid."
+      else
+        lines << "#{path}: deps.yaml schema is invalid (#{@errors.size} errors):"
+        @errors.each { |e| lines << "  ✗ #{e}" }
+      end
+      @warnings.each { |w| lines << "  ⚠ #{w}" }
+      lines.join("\n")
+    end
+
+    private
+
+    def validate
+      unless @raw.is_a?(Hash) && !@raw.empty?
+        @errors << Issue.new(
+          '(root)',
+          'file must be a non-empty mapping: canonical name -> { targets: ... }'
+        )
+        return
+      end
+      @raw.each { |name, body| validate_dep(name.to_s, body) }
+    end
+
+    def validate_dep(name, body)
+      if name !~ CANONICAL_NAME_RE
+        @errors << Issue.new(
+          name,
+          "invalid canonical name #{name.inspect} " \
+          '(lowercase letters, digits, "-", "_", "."; must start with a letter or digit)'
+        )
+      end
+      unless KNOWN_CANONICAL.include?(name)
+        @warnings << Issue.new(
+          name,
+          'unknown to crosspack — not an error if the rules below are correct (possible typo?)'
+        )
+      end
+      unless body.is_a?(Hash) && body.key?('targets')
+        @errors << Issue.new(
+          name,
+          "missing required field targets; expected:\n" \
+          "    #{name}:\n      targets:\n        debian:\n          \"12\": [package]"
+        )
+        return
+      end
+
+      targets = body['targets']
+      unless targets.is_a?(Hash) && !targets.empty?
+        @errors << Issue.new(
+          "#{name}.targets",
+          "must be a non-empty mapping: family -> rules (debian, ubuntu, fedora, ...)"
+        )
+        return
+      end
+      targets.each { |family, rules| validate_family(name, family.to_s, rules) }
+    end
+
+    def validate_family(name, family, rules)
+      path = "#{name}.targets.#{family}"
+      known = Target::FAMILIES.map(&:to_s)
+      unless known.include?(family)
+        suggestion = suggest(family, known)
+        hint = suggestion ? " (did you mean #{suggestion.inspect}?)" : ''
+        @errors << Issue.new(
+          path,
+          "unknown distro family #{family.inspect}#{hint}; " \
+          "allowed: #{known.join(', ')}"
+        )
+        return
+      end
+
+      if rules.is_a?(String)
+        validate_verdict(path, rules)
+        return
+      end
+      unless rules.is_a?(Hash) && !rules.empty?
+        @errors << Issue.new(
+          path,
+          "expected a mapping { \"version\": [packages], ... } or a scalar: #{VERDICTS.join(' / ')}"
+        )
+        return
+      end
+
+      rules.each do |version, value|
+        vpath = "#{path}.#{version.inspect}"
+        unless version.is_a?(String)
+          @errors << Issue.new(
+            vpath,
+            "version key must be a quoted string: \"#{version}\" — " \
+            'without quotes YAML parses it as a number'
+          )
+          next
+        end
+        if value.is_a?(String)
+          validate_verdict(vpath, value)
+        elsif value.is_a?(Array)
+          validate_package_list(vpath, value)
+        else
+          @errors << Issue.new(
+            vpath,
+            "value must be a list of packages [pkg, ...] or a scalar: #{VERDICTS.join(' / ')}"
+          )
+        end
+      end
+    end
+
+    def validate_verdict(path, value)
+      return if VERDICTS.include?(value)
+
+      @errors << Issue.new(
+        path,
+        "unknown verdict #{value.inspect}; allowed: #{VERDICTS.join(' / ')}"
+      )
+    end
+
+    def validate_package_list(path, value)
+      if value.empty?
+        @errors << Issue.new(
+          path,
+          'package list is empty — specify at least one package or the none verdict'
+        )
+        return
+      end
+      value.each_with_index do |pkg, i|
+        next if pkg.is_a?(String) && !pkg.strip.empty? && pkg == pkg.strip
+
+        @errors << Issue.new(
+          "#{path}[#{i}]",
+          'package name must be a non-empty string without surrounding whitespace'
+        )
+      end
+    end
+
+    def suggest(word, candidates)
+      best = candidates.min_by { |c| levenshtein(word, c) }
+      distance = levenshtein(word, best)
+      distance <= 2 ? best : nil
+    end
+
+    def levenshtein(a, b)
+      prev = (0..b.length).to_a
+      a.chars.each_with_index do |ca, i|
+        curr = [i + 1]
+        b.chars.each_with_index do |cb, j|
+          cost = ca == cb ? 0 : 1
+          curr[j + 1] = [
+            curr[j] + 1,        # insertion
+            prev[j + 1] + 1,    # deletion
+            prev[j] + cost      # substitution
+          ].min
+        end
+        prev = curr
+      end
+      prev[b.length]
+    end
+  end
+end

data/lib/crosspack/matrix.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Crosspack
+  # Renders the dependency x target matrix straight from the manifest.
+  # Columns come from the targets declared in deps.yaml itself.
+  class Matrix
+    def initialize(manifest)
+      @manifest = manifest
+    end
+
+    def render
+      columns = target_columns
+      return 'deps.yaml is empty — nothing to show.' if columns.empty?
+
+      header = ['dependency'] + columns.map(&:to_s)
+      rows = @manifest.deps.map do |name, body|
+        [name] + columns.map { |t| cell(body['targets'], t) }
+      end
+
+      widths = header.each_index.map do |i|
+        ([header[i].length] + rows.map { |r| r[i].to_s.length }).max
+      end
+      lines = ([header] + rows).map do |row|
+        row.each_with_index.map { |c, i| c.to_s.ljust(widths[i]) }.join('  ')
+      end
+      lines.join("\n")
+    end
+
+    private
+
+    # Every target mentioned in the manifest: family + version pairs,
+    # ordered by the canonical family list.
+    def target_columns
+      cols = []
+      Target::FAMILIES.each do |family|
+        versions = Set.new
+        @manifest.deps.each_value do |body|
+          rule = body['targets'][family.to_s]
+          next if rule.nil?
+
+          if rule.is_a?(String)
+            versions.add(nil)
+          else
+            rule.each_key { |v| versions.add(v == '*' ? nil : v) }
+          end
+        end
+        versions.to_a.sort_by(&:to_s).each do |v|
+          cols << Target.new(family, v)
+        end
+      end
+      cols
+    end
+
+    def cell(targets, target)
+      rule = targets[target.family.to_s]
+      return '—' if rule.nil?
+
+      value = rule.is_a?(String) ? rule : (rule[target.version] || rule['*'])
+      return '(no rule)' if value.nil?
+      return value unless value.is_a?(Array)
+
+      value.join(' | ')
+    end
+  end
+end

data/lib/crosspack/package_manifest.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Crosspack
+  # Packaging manifest (package.yaml): declares WHAT and HOW to pack —
+  # payload, executables, symlinks, desktop entry, icon. Compilation is not
+  # crosspack's business; artifacts are picked from `sources` as-is.
+  class PackageManifest
+    REQUIRED = %w[name maintainer description sources prefix payload].freeze
+    OPTIONAL = %w[summary license section lib_dir executables links desktop icon].freeze
+
+    attr_reader :path, :data, :errors, :warnings
+
+    def self.load(path)
+      unless File.file?(path)
+        raise InvalidManifestError,
+              "Packaging manifest not found: #{path}\n" \
+              'Create package.yaml next to the Rakefile (see crosspack/README.md).'
+      end
+      begin
+        raw = YAML.safe_load(File.read(path), permitted_classes: [], aliases: false)
+      rescue Psych::SyntaxError => e
+        raise InvalidManifestError,
+              "#{path}: YAML syntax error on line #{e.line}: #{e.problem}"
+      end
+      new(path, raw)
+    end
+
+    def initialize(path, raw)
+      @path = path
+      @data = raw.is_a?(Hash) ? raw : {}
+      @raw = raw
+      @errors = []
+      @warnings = []
+      validate
+    end
+
+    def valid?
+      @errors.empty?
+    end
+
+    def validate!
+      return self if valid?
+
+      lines = ["#{path}: package.yaml schema is invalid (#{@errors.size} errors):"]
+      @errors.each { |e| lines << "  ✗ #{e}" }
+      lines << 'Packing aborted: fix the listed nodes and retry.'
+      raise InvalidManifestError, lines.join("\n")
+    end
+
+    def error_report
+      if valid?
+        "#{path}: schema is valid."
+      else
+        ["#{path}: package.yaml schema is invalid (#{@errors.size} errors):",
+         *@errors.map { |e| "  ✗ #{e}" }].join("\n")
+      end
+    end
+
+    # ---- typed accessors (validated values) ----
+
+    def name
+      @data['name']
+    end
+
+    def maintainer
+      @data['maintainer']
+    end
+
+    def description
+      @data['description'].to_s
+    end
+
+    def license
+      @data['license'] || 'Proprietary'
+    end
+
+    def section
+      @data['section'] || 'utils'
+    end
+
+    def sources
+      @data['sources']
+    end
+
+    def prefix
+      @data['prefix']
+    end
+
+    def payload
+      Array(@data['payload'])
+    end
+
+    def executables
+      Array(@data['executables'])
+    end
+
+    def summary
+      @data['summary'] || description.lines.map(&:chomp).reject(&:empty?).first || name
+    end
+
+    def lib_dir
+      @data['lib_dir'] || File.join('lib', name.to_s)
+    end
+
+    def links
+      @data['links'].is_a?(Hash) ? @data['links'] : {}
+    end
+
+    def desktop
+      @data['desktop'].is_a?(Hash) ? @data['desktop'] : nil
+    end
+
+    def icon
+      @data['icon']
+    end
+
+    private
+
+    def validate
+      unless @raw.is_a?(Hash) && !@raw.empty?
+        @errors << Issue.new('(root)', 'file must be a non-empty mapping: name, maintainer, payload, ...')
+        return
+      end
+
+      REQUIRED.each do |key|
+        next unless @data[key].nil?
+
+        @errors << Issue.new(key, 'required field is missing')
+      end
+
+      unknown = @data.keys - REQUIRED - OPTIONAL
+      unknown.each do |key|
+        @errors << Issue.new(key, "unknown field; allowed: #{(REQUIRED + OPTIONAL).sort.join(', ')}")
+      end
+
+      validate_string('name', /\A[a-z0-9][a-z0-9+._-]*\z/)
+      validate_string('maintainer', nil)
+      validate_string('description', nil)
+      validate_string('sources', nil)
+      validate_string('prefix', /\A[a-z0-9][a-z0-9+._\/-]*\z/)
+      validate_payload
+      validate_executables
+      validate_links
+      validate_desktop
+    end
+
+    def validate_string(key, re)
+      value = @data[key]
+      return if value.nil? # already reported via REQUIRED
+
+      if !value.is_a?(String) || value.strip.empty?
+        @errors << Issue.new(key, 'must be a non-empty string')
+        return
+      end
+      return unless re && !value.match?(re)
+
+      @errors << Issue.new(key, "invalid value #{value.inspect}")
+    end
+
+    def validate_payload
+      value = @data['payload']
+      return if value.nil? # already reported as missing
+
+      unless value.is_a?(Array) && !value.empty?
+        @errors << Issue.new('payload', 'must be a non-empty list of artifact files from sources')
+        return
+      end
+      value.each_with_index do |item, i|
+        next if item.is_a?(String) && !item.strip.empty? && !item.start_with?('/')
+
+        @errors << Issue.new("payload[#{i}]", 'file name must be a non-empty relative string (no leading "/")')
+      end
+    end
+
+    def validate_executables
+      value = @data['executables']
+      return if value.nil?
+
+      unless value.is_a?(Array)
+        @errors << Issue.new('executables', 'must be a list of names from payload')
+        return
+      end
+      value.each do |exe|
+        next if payload.include?(exe)
+
+        @errors << Issue.new('executables', "#{exe.inspect} is not in payload — only files from payload can be executable")
+      end
+    end
+
+    def validate_links
+      value = @data['links']
+      return if value.nil?
+
+      unless value.is_a?(Hash) && !value.empty?
+        @errors << Issue.new('links', 'must be a mapping: relative symlink path -> target')
+        return
+      end
+      value.each do |link, target|
+        if link.to_s.start_with?('/')
+          @errors << Issue.new("links.#{link}", 'symlink path must be relative to prefix (no leading "/")')
+        end
+        unless target.is_a?(String) && !target.strip.empty?
+          @errors << Issue.new("links.#{link}", 'symlink target must be a non-empty string')
+        end
+      end
+    end
+
+    def validate_desktop
+      value = @data['desktop']
+      return if value.nil?
+
+      unless value.is_a?(Hash) && !value.empty?
+        @errors << Issue.new('desktop', 'must be a mapping: name, comment, categories, exec (optional)')
+      end
+    end
+  end
+end