pray-cli 1.6.0

data/lib/pray/cli/parse.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require_relative "parse_trust"
+require_relative "parse_auth"
+
+module Pray
+  module CLI
+    def parse_command(arguments)
+      arguments = arguments.dup
+      flags = {
+        check: extract_flag!(arguments, "--check"),
+        strict: extract_flag!(arguments, "--strict"),
+        semantic: extract_flag!(arguments, "--semantic"),
+        locked: false,
+        frozen: false,
+        offline: false,
+        targets: []
+      }
+
+      arguments.each do |argument|
+        case argument
+        when "--locked" then flags[:locked] = true
+        when "--frozen" then flags[:locked] = flags[:frozen] = true
+        when "--offline" then flags[:offline] = true
+        end
+      end
+      arguments.reject! { |argument| %w[--locked --frozen --offline].include?(argument) }
+
+      command = arguments.shift
+      raise Error.usage("pray requires a command; run pray --help") unless command
+
+      case command
+      when "manifest" then [:manifest]
+      when "init"
+        targets = []
+        while (argument = arguments.shift)
+          if argument == "--targets"
+            targets = arguments.shift.to_s.split(",").map(&:strip).reject(&:empty?)
+          end
+        end
+        [:init, targets]
+      when "prayer"
+        raise Error.unsupported("prayer requires init") unless arguments.shift == "init"
+
+        [:prayer_init]
+      when "repo"
+        raise Error.unsupported("repo requires init") unless arguments.shift == "init"
+
+        [:repo_init]
+      when "install" then [:install, flags]
+      when "add" then [:add, parse_add_arguments(arguments)]
+      when "remove" then [:remove, arguments.shift]
+      when "update" then [:update, arguments]
+      when "unlock" then [:unlock, arguments.shift]
+      when "render" then [:render, flags]
+      when "plan" then [:plan, arguments]
+      when "apply" then [:apply]
+      when "verify" then [:verify, flags]
+      when "drift" then [:drift, flags]
+      when "format", "fmt" then [:format]
+      when "package" then [:package]
+      when "publish" then [:publish, parse_publish_arguments(arguments)]
+      when "login" then [:login, parse_login_arguments(arguments)]
+      when "serve" then [:serve, parse_serve_arguments(arguments)]
+      when "confess" then [:confess, parse_confess_arguments(arguments)]
+      when "list" then [:list]
+      when "outdated" then [:outdated, arguments]
+      when "explain" then [:explain, arguments.shift]
+      when "vendor" then [:vendor]
+      when "clean" then [:clean]
+      when "tree" then [:tree]
+      when "sync" then [:sync, parse_sync_arguments(arguments)]
+      when "trust" then parse_trust_command(arguments)
+      when "version", "-V", "--version" then [:version]
+      else
+        raise Error.usage(Suggest.unknown_command_message(command))
+      end
+    end
+
+    def extract_flag!(arguments, flag)
+      found = arguments.include?(flag)
+      arguments.reject! { |argument| argument == flag }
+      found
+    end
+
+    def parse_add_arguments(arguments)
+      name = arguments.shift
+      raise Error.unsupported("add requires a package name") unless name
+
+      constraint = nil
+      path = nil
+      while (argument = arguments.shift)
+        case argument
+        when "--path"
+          path = arguments.shift
+        else
+          constraint ||= argument
+        end
+      end
+      {name: name, constraint: constraint, path: path}
+    end
+
+    def parse_publish_arguments(arguments)
+      roots = []
+      servers = []
+      while (argument = arguments.shift)
+        case argument
+        when "--root"
+          roots << arguments.shift
+        when "--server"
+          servers << arguments.shift
+        else
+          raise Error.unsupported("unexpected publish argument: #{argument}")
+        end
+      end
+      raise Error.unsupported("publish requires at least one --root PATH or --server URL") if roots.empty? && servers.empty?
+
+      {roots: roots, servers: servers}
+    end
+
+    def parse_serve_arguments(arguments)
+      options = {root: ".", host: "127.0.0.1", port: 7429, stdio: false}
+      while (argument = arguments.shift)
+        case argument
+        when "--root" then options[:root] = arguments.shift
+        when "--host" then options[:host] = arguments.shift
+        when "--port" then options[:port] = Integer(arguments.shift)
+        when "--stdio" then options[:stdio] = true
+        else
+          raise Error.unsupported("unexpected serve argument: #{argument}")
+        end
+      end
+      options
+    end
+  end
+end

data/lib/pray/cli/parse_auth.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Pray
+  module CLI
+    def parse_login_arguments(arguments)
+      servers = []
+      email = nil
+      passkey_key = nil
+      credential_id = nil
+      ssh_agent = false
+      public_key = nil
+      while (argument = arguments.shift)
+        case argument
+        when "--server" then servers << arguments.shift
+        when "--email" then email = arguments.shift
+        when "--passkey-key" then passkey_key = arguments.shift
+        when "--credential-id" then credential_id = arguments.shift
+        when "--ssh-agent" then ssh_agent = true
+        when "--public-key" then public_key = arguments.shift
+        else
+          raise Error.unsupported("unknown login argument: #{argument}")
+        end
+      end
+      raise Error.unsupported("login requires --server URL") if servers.empty?
+      raise Error.unsupported("login requires --email EMAIL") if email.to_s.empty?
+
+      passkey = passkey_key || credential_id
+      if passkey && ssh_agent
+        raise Error.unsupported("login accepts either passkey or ssh-agent mode, not both")
+      end
+      if passkey_key
+        raise Error.unsupported("passkey login requires --credential-id") if credential_id.to_s.empty?
+
+        {servers: servers, email: email, mode: :passkey, passkey_key: passkey_key,
+         credential_id: credential_id}
+      elsif ssh_agent
+        raise Error.unsupported("ssh-agent login requires --public-key") if public_key.to_s.empty?
+
+        {servers: servers, email: email, mode: :ssh_agent, public_key: public_key}
+      else
+        raise Error.unsupported("login requires --passkey-key/--credential-id or --ssh-agent")
+      end
+    end
+
+    def parse_confess_arguments(arguments)
+      package = nil
+      from_lock = nil
+      version = nil
+      accepted = false
+      rejected = false
+      note = nil
+      url = nil
+      while (argument = arguments.shift)
+        case argument
+        when "--from-lock" then from_lock = arguments.shift
+        when "--version" then version = arguments.shift
+        when "--accepted" then accepted = true
+        when "--rejected" then rejected = true
+        when "--note" then note = arguments.shift
+        when "--url" then url = arguments.shift
+        when /\A-/ then raise Error.unsupported("unknown confess argument: #{argument}")
+        else package = argument
+        end
+      end
+      if accepted == rejected
+        raise Error.unsupported("confess requires exactly one of --accepted or --rejected")
+      end
+      if package && from_lock
+        raise Error.unsupported("confess accepts either a package name or --from-lock")
+      end
+      raise Error.unsupported("confess requires a package name") if package.nil? && from_lock.nil?
+
+      {package: package, from_lock: from_lock, version: version, accepted: accepted,
+       rejected: rejected, note: note, url: url}
+    end
+
+    def parse_sync_arguments(arguments)
+      root = "."
+      peers = []
+      while (argument = arguments.shift)
+        case argument
+        when "--root" then root = arguments.shift
+        when "--peer" then peers << arguments.shift
+        else
+          raise Error.unsupported("unknown sync argument: #{argument}")
+        end
+      end
+      {root: root, peers: peers}
+    end
+  end
+end

data/lib/pray/cli/parse_trust.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module Pray
+  module CLI
+    def parse_trust_command(arguments)
+      subcommand = arguments.shift
+      raise Error.unsupported("trust requires a subcommand") unless subcommand
+
+      case subcommand
+      when "list" then [:trust_list, parse_trust_list_arguments(arguments)]
+      when "show"
+        raise Error.unsupported("unknown trust show argument: #{arguments.first}") if arguments.any?
+
+        [:trust_show]
+      when "add-key" then [:trust_add_key, parse_trust_key_arguments(arguments, "add-key")]
+      when "remove-key", "revoke"
+        [:trust_remove_key, parse_trust_key_arguments(arguments, "remove-key")]
+      when "set-signed" then [:trust_set_signed, parse_trust_set_signed_arguments(arguments)]
+      when "set-allow" then [:trust_set_allow, parse_trust_set_allow_arguments(arguments)]
+      when "import-repo" then [:trust_import_repo, parse_trust_import_repo_arguments(arguments)]
+      when "import-registry"
+        [:trust_import_registry, parse_trust_import_registry_arguments(arguments)]
+      when "check"
+        source = arguments.shift
+        raise Error.unsupported("trust check accepts at most one SOURCE argument") if arguments.any?
+
+        [:trust_check, source]
+      else
+        raise Error.unsupported("unknown trust command: #{subcommand}")
+      end
+    end
+
+    def parse_trust_list_arguments(arguments)
+      scope = :all
+      source_url = nil
+      arguments.each do |argument|
+        case argument
+        when "--global" then scope = :global
+        when "--local" then scope = :local
+        when /\A-/ then raise Error.unsupported("unknown trust list argument: #{argument}")
+        else source_url = argument
+        end
+      end
+      {scope: scope, source_url: source_url}
+    end
+
+    def parse_trust_key_arguments(arguments, label)
+      key = arguments.shift
+      raise Error.unsupported("trust #{label} requires KEY") unless key
+
+      match_prefix = nil
+      while (argument = arguments.shift)
+        if argument == "--match-prefix"
+          match_prefix = arguments.shift
+          raise Error.unsupported("--match-prefix requires VALUE") unless match_prefix
+        else
+          raise Error.unsupported("unknown trust #{label} argument: #{argument}")
+        end
+      end
+      {key: key, match_prefix: match_prefix}
+    end
+
+    def parse_trust_set_signed_arguments(arguments)
+      match_prefix = nil
+      enabled = true
+      while (argument = arguments.shift)
+        case argument
+        when "--match-prefix"
+          match_prefix = arguments.shift
+          raise Error.unsupported("--match-prefix requires VALUE") unless match_prefix
+        when "--enabled"
+          value = arguments.shift
+          raise Error.unsupported("--enabled requires true|false") unless value
+
+          enabled = parse_bool_flag(value)
+        else
+          raise Error.unsupported("unknown trust set-signed argument: #{argument}")
+        end
+      end
+      raise Error.unsupported("trust set-signed requires --match-prefix PREFIX") unless match_prefix
+
+      {match_prefix: match_prefix, enabled: enabled}
+    end
+
+    def parse_trust_set_allow_arguments(arguments)
+      match_prefix = nil
+      allow = true
+      while (argument = arguments.shift)
+        case argument
+        when "--match-prefix"
+          match_prefix = arguments.shift
+          raise Error.unsupported("--match-prefix requires VALUE") unless match_prefix
+        when "--allow"
+          value = arguments.shift
+          raise Error.unsupported("--allow requires true|false") unless value
+
+          allow = parse_bool_flag(value)
+        else
+          raise Error.unsupported("unknown trust set-allow argument: #{argument}")
+        end
+      end
+      raise Error.unsupported("trust set-allow requires --match-prefix PREFIX") unless match_prefix
+
+      {match_prefix: match_prefix, allow: allow}
+    end
+
+    def parse_trust_import_repo_arguments(arguments)
+      source_url = arguments.shift
+      raise Error.unsupported("trust import-repo requires SOURCE_URL") unless source_url
+
+      match_prefix = nil
+      while (argument = arguments.shift)
+        if argument == "--match-prefix"
+          match_prefix = arguments.shift
+          raise Error.unsupported("--match-prefix requires VALUE") unless match_prefix
+        else
+          raise Error.unsupported("unknown trust import-repo argument: #{argument}")
+        end
+      end
+      {source_url: source_url, match_prefix: match_prefix}
+    end
+
+    def parse_trust_import_registry_arguments(arguments)
+      source_url = arguments.shift
+      raise Error.unsupported("trust import-registry requires SOURCE_URL") unless source_url
+
+      match_prefix = nil
+      include_host_key = source_url.start_with?("pray+ssh://", "ssh+pray://")
+      while (argument = arguments.shift)
+        case argument
+        when "--match-prefix"
+          match_prefix = arguments.shift
+          raise Error.unsupported("--match-prefix requires VALUE") unless match_prefix
+        when "--host-key" then include_host_key = true
+        when "--no-host-key" then include_host_key = false
+        else
+          raise Error.unsupported("unknown trust import-registry argument: #{argument}")
+        end
+      end
+      {source_url: source_url, match_prefix: match_prefix, include_host_key: include_host_key}
+    end
+
+    def parse_bool_flag(value)
+      case value.downcase
+      when "true", "1", "yes", "on" then true
+      when "false", "0", "no", "off" then false
+      else
+        raise Error.unsupported("expected true|false, got #{value}")
+      end
+    end
+  end
+end

data/lib/pray/cli/suggest.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Pray
+  module CLI
+    module Suggest
+      TOP_LEVEL_COMMANDS = %w[
+        add apply clean confess drift explain fmt format help init install list login manifest
+        outdated package plan prayer publish remove render repo serve sync tree trust unlock
+        update vendor verify version
+      ].freeze
+
+      module_function
+
+      def unknown_command_message(command)
+        message = "unknown command: #{command}"
+        suggestion = suggest_command(command, TOP_LEVEL_COMMANDS)
+        suggestion ? "#{message}\nDid you mean `#{suggestion}`?" : message
+      end
+
+      def suggest_command(input, candidates)
+        maximum_distance = (input.length <= 3) ? 1 : 2
+        candidates
+          .map { |candidate| [candidate, levenshtein_distance(input, candidate)] }
+          .select { |(_, distance)| distance <= maximum_distance }
+          .min_by { |(_, distance)| distance }
+          &.first
+      end
+
+      def levenshtein_distance(left, right)
+        left_chars = left.chars
+        right_chars = right.chars
+        left_length = left_chars.length
+        right_length = right_chars.length
+        return right_length if left_length.zero?
+        return left_length if right_length.zero?
+
+        previous_row = (0..right_length).to_a
+        current_row = Array.new(right_length + 1, 0)
+
+        left_chars.each_with_index do |left_character, left_index|
+          current_row[0] = left_index + 1
+          right_chars.each_with_index do |right_character, right_index|
+            substitution_cost = (left_character == right_character) ? 0 : 1
+            current_row[right_index + 1] = [
+              previous_row[right_index + 1] + 1,
+              current_row[right_index] + 1,
+              previous_row[right_index] + substitution_cost
+            ].min
+          end
+          previous_row, current_row = current_row, previous_row
+        end
+
+        previous_row[right_length]
+      end
+    end
+  end
+end

data/lib/pray/cli.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+require_relative "invocation"
+require_relative "cli/parse"
+require_relative "cli/help"
+require_relative "cli/suggest"
+require_relative "cli/helpers"
+require_relative "cli/commands/init"
+require_relative "cli/commands/workflow"
+require_relative "cli/commands/packages"
+require_relative "cli/commands/distribution"
+require_relative "cli/commands/trust"
+require_relative "cli/commands/auth"
+require_relative "cli/commands/meta"
+
+module Pray
+  module CLI
+    MANIFEST_PATH = "Prayfile"
+    LOCKFILE_PATH = "Prayfile.lock"
+
+    def run(arguments)
+      arguments = arguments.dup
+      if arguments.delete("--no-input")
+        ENV["PRAY_NO_INPUT"] = "1"
+      end
+      arguments = Invocation.initialize(arguments)
+      return if maybe_print_help(arguments)
+
+      command = parse_command(arguments)
+      dispatch(command)
+    end
+
+    def maybe_print_help(arguments)
+      if arguments.empty?
+        Help.print_concise_help
+        return true
+      end
+
+      if arguments.length == 1 && %w[help -h --help].include?(arguments[0])
+        Help.print_concise_help
+        return true
+      end
+
+      if arguments[0] == "help"
+        target = arguments[1] || ""
+        if target.empty? || %w[-h --help].include?(target)
+          Help.print_concise_help
+          return true
+        end
+        return true if Help.print_command_help(target)
+
+        raise Error.usage(Suggest.unknown_command_message(target))
+      end
+
+      help_position = arguments.index { |argument| %w[--help -h].include?(argument) }
+      if help_position
+        if help_position.zero?
+          Help.print_concise_help
+          return true
+        end
+        command = arguments[0]
+        return true if Help.print_command_help(command)
+
+        raise Error.usage("unknown command: #{command}")
+      end
+
+      false
+    end
+
+    def dispatch(command)
+      case command
+      in [:manifest] then manifest_command
+      in [:init, targets] then init_command(targets)
+      in [:prayer_init] then prayer_init_command
+      in [:repo_init] then repo_init_command
+      in [:install, flags] then install_command(flags)
+      in [:add, add_args] then add_command(**add_args)
+      in [:remove, name] then remove_command(name)
+      in [:update, arguments] then update_command(arguments)
+      in [:unlock, name] then unlock_command(name)
+      in [:render, flags] then render_command(flags)
+      in [:plan, arguments] then plan_command(arguments)
+      in [:apply] then install_command({locked: false, frozen: false, offline: false})
+      in [:verify, flags] then verify_command(flags)
+      in [:drift, flags] then drift_command(flags)
+      in [:format] then format_command
+      in [:package] then package_command
+      in [:publish, publish_args] then publish_command(**publish_args)
+      in [:unsupported, name] then raise Error.unsupported("#{name} is not implemented yet in pray-cli Ruby")
+      in [:serve, serve_args] then serve_command(**serve_args)
+      in [:login, login_args] then login_command(**login_args)
+      in [:confess, confess_args] then confess_command(**confess_args)
+      in [:sync, sync_args] then sync_command(**sync_args)
+      in [:list] then list_command
+      in [:outdated, arguments] then outdated_command(arguments)
+      in [:explain, name] then explain_command(name)
+      in [:vendor] then raise Error.unsupported("vendor is not implemented yet in pray-cli Ruby")
+      in [:clean] then clean_command
+      in [:tree] then tree_command
+      in [:trust_list, options] then trust_list_command(**options)
+      in [:trust_show] then trust_show_command
+      in [:trust_add_key, options] then trust_add_key_command(**options)
+      in [:trust_remove_key, options] then trust_remove_key_command(**options)
+      in [:trust_set_signed, options] then trust_set_signed_command(**options)
+      in [:trust_set_allow, options] then trust_set_allow_command(**options)
+      in [:trust_import_repo, options] then trust_import_repo_command(**options)
+      in [:trust_import_registry, options] then trust_import_registry_command(**options)
+      in [:trust_check, source] then trust_check_command(source)
+      in [:version] then version_command
+      end
+    end
+
+    extend self
+  end
+end

data/lib/pray/confess.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "session"
+
+module Pray
+  ConfessionSubmission = Struct.new(
+    :package, :version, :status, :note, :lockfile,
+    :distribution_point, :signer, :timestamp, :signature,
+    keyword_init: true
+  )
+
+  module Confess
+    module_function
+
+    def submit(package:, from_lock:, version:, accepted:, rejected:, note:, url:,
+      project_root: Dir.pwd)
+      raise Error.unsupported("confess requires exactly one of --accepted or --rejected") if accepted == rejected
+
+      manifest_path = File.join(project_root, "Prayfile")
+      project = Resolve.resolve_project(manifest_path)
+      lockfile_path = File.join(project_root, "Prayfile.lock")
+      lockfile = File.file?(lockfile_path) ? Lockfile.read_lockfile(lockfile_path) : nil
+
+      package_name, resolved_version, package_resolution =
+        resolve_target(project, lockfile, package, from_lock, version)
+      source_url = resolve_source_url(project, package_resolution, package_name, url)
+      if source_url.start_with?("pray+ssh://", "ssh+pray://")
+        raise Error.unsupported("pray_ssh confession submit is not implemented yet in pray-cli Ruby")
+      end
+
+      confession = ConfessionSubmission.new(
+        package: package_name,
+        version: resolved_version,
+        status: accepted ? "accepted" : "rejected",
+        note: note,
+        lockfile: lockfile&.file_hash,
+        distribution_point: source_url,
+        signer: Session.current_signer(project_root),
+        timestamp: Time.now.to_i.to_s,
+        signature: nil
+      )
+      confession.signature = Hashing.sha256_prefixed(JSON.generate(confession_to_hash(confession)))
+      Registry.http_post(
+        Registry.join_url(source_url, "v1/confessions"),
+        "application/json",
+        JSON.generate(confession_to_hash(confession))
+      )
+      puts "Confession submitted for #{confession.package} #{confession.version}"
+    end
+
+    def resolve_target(project, lockfile, package, from_lock, version)
+      if from_lock
+        raise Error.resolution("confess --from-lock requires an existing lockfile") unless lockfile
+
+        span = lockfile.managed_span.find { |record| record.id == from_lock }
+        raise Error.resolution("lockfile span #{from_lock} not found") unless span
+
+        package_resolution = project.packages.find { |entry| entry.declaration.name == span.package }
+        raise Error.resolution("package #{span.package} not found") unless package_resolution
+
+        locked = lockfile.package.find { |entry| entry.name == span.package }
+        raise Error.resolution("lockfile package #{span.package} not found") unless locked
+
+        if version && version != locked.version
+          raise Error.resolution(
+            "lockfile span #{from_lock} version #{locked.version} does not match requested version #{version}"
+          )
+        end
+        [span.package, version || locked.version, package_resolution]
+      else
+        raise Error.unsupported("confess requires a package name") unless package
+
+        package_resolution = project.packages.find { |entry| entry.declaration.name == package }
+        raise Error.resolution("package #{package} not found") unless package_resolution
+
+        if version && version != package_resolution.spec.version
+          raise Error.resolution(
+            "package #{package} version #{version} does not match resolved version #{package_resolution.spec.version}"
+          )
+        end
+        [package, version || package_resolution.spec.version, package_resolution]
+      end
+    end
+
+    def resolve_source_url(project, package_resolution, package_name, url)
+      return url if url
+
+      source_name = package_resolution.declaration.source
+      raise Error.resolution("package #{package_name} is missing a source") unless source_name
+
+      source = project.manifest.sources.find { |entry| entry.name == source_name }
+      raise Error.resolution("unknown source: #{source_name}") unless source
+
+      source.url
+    end
+
+    def confession_to_hash(confession)
+      hash = {
+        "package" => confession.package,
+        "version" => confession.version,
+        "status" => confession.status
+      }
+      hash["note"] = confession.note if confession.note
+      hash["lockfile"] = confession.lockfile if confession.lockfile
+      hash["distribution_point"] = confession.distribution_point if confession.distribution_point
+      hash["signer"] = confession.signer if confession.signer
+      hash["timestamp"] = confession.timestamp if confession.timestamp
+      hash["signature"] = confession.signature if confession.signature
+      hash
+    end
+  end
+end