pray-cli 1.6.0

data/lib/pray/format_serialize.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Pray
+  module FormatSerialize
+    module_function
+
+    def serialize_recommended(manifest)
+      lines = [%(prayfile "#{manifest.prayfile_version}")]
+
+      unless manifest.sources.empty?
+        lines << ""
+        manifest.sources.each { |source| lines << format_source(source) }
+      end
+
+      unless manifest.symbols.empty?
+        lines << ""
+        lines << "pray do"
+        manifest.symbols.sort.each do |key, value|
+          lines << %(  #{key} "#{value}")
+        end
+        lines << "end"
+      end
+
+      manifest.targets.each do |target|
+        next unless target.scoped
+
+        lines << ""
+        case target.mode
+        when "compose"
+          path = target.outputs.first || ""
+          lines << %(compose "#{path}" do)
+          target.entries.each do |entry|
+            lines << "  #{format_destination_entry(entry, manifest)}"
+          end
+          lines << "end"
+        when "tree"
+          path = target.skills.first || ""
+          lines << %(tree "#{path}" do)
+          target.entries.each do |entry|
+            next unless entry.kind == "package"
+
+            package = find_package(manifest, entry.name)
+            lines << "  #{ManifestMethods.format_package_declaration(package)}" if package
+          end
+          lines << "end"
+        end
+      end
+
+      file_packages = manifest.packages.select(&:file)
+      unless file_packages.empty?
+        lines << ""
+        file_packages.each { |package| lines << ManifestMethods.format_package_declaration(package) }
+      end
+
+      unbound = manifest.packages.select { |package| !package.bound && !package.file && package.groups.empty? }
+      unless unbound.empty?
+        lines << ""
+        unbound.each { |package| lines << ManifestMethods.format_package_declaration(package) }
+      end
+
+      grouped_packages(manifest).each do |group_names, packages|
+        lines << ""
+        lines << "group #{group_names.map { |name| ":#{name}" }.join(", ")} do"
+        packages.each { |package| lines << "  #{ManifestMethods.format_package_declaration(package)}" }
+        lines << "end"
+      end
+
+      manifest.targets.each do |target|
+        next if target.scoped || !target_has_extras?(target)
+
+        lines << ""
+        lines << "target :#{target.name} do"
+        target.commands.each { |command| lines << %(  commands "#{command}") }
+        target.rules.each { |rule| lines << %(  rules "#{rule}") }
+        lines << "  max_bytes #{target.max_bytes}" if target.max_bytes
+        lines << "end"
+      end
+
+      if manifest.render != RenderPolicy.default
+        lines << ""
+        lines << "render mode: :#{manifest.render.mode}, conflict: :#{manifest.render.conflict}, " \
+                 "churn: :#{manifest.render.churn}"
+      end
+
+      lines << ""
+      lines.join("\n")
+    end
+
+    def target_has_extras?(target)
+      !target.commands.empty? || !target.rules.empty? || !target.max_bytes.nil?
+    end
+
+    def format_source(source)
+      parts = [%(source "#{source.name}")]
+      case source.kind
+      when "path"
+        parts << %(path: "#{source.url}")
+      when "git"
+        url = source.url.delete_prefix("git+")
+        parts << %(git: "#{url}")
+      else
+        parts << %("#{source.url}")
+      end
+      parts << %(distribution: "#{source.subdir}") if source.subdir
+      parts << %(tag: "#{source.tag}") if source.tag
+      parts << %(rev: "#{source.rev}") if source.rev
+      parts.join(", ")
+    end
+
+    def format_destination_entry(entry, manifest)
+      if entry.kind == "local"
+        return %(pray "#{entry.path}")
+      end
+
+      package = find_package(manifest, entry.name)
+      package ? ManifestMethods.format_package_declaration(package) : %(pray "#{entry.name}")
+    end
+
+    def find_package(manifest, name)
+      manifest.packages.find { |package| package.name == name }
+    end
+
+    def grouped_packages(manifest)
+      groups = {}
+      manifest.packages.each do |package|
+        next if package.groups.empty?
+
+        key = package.groups.dup
+        groups[key] ||= []
+        groups[key] << package
+      end
+      groups.sort_by { |names, _| names }.map { |names, packages| [names, packages] }
+    end
+  end
+end

data/lib/pray/git_sources.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require "open3"
+require "fileutils"
+require "pathname"
+
+module Pray
+  GitSourceCheckout = Struct.new(:cache_directory, :revision, :subdir)
+
+  module GitSources
+    module_function
+
+    def prepare_git_sources(project_root, sources, lockfile, refresh: false)
+      checkouts = {}
+      sources.each do |source|
+        next unless source.kind == "git"
+
+        clone_url = source.url.delete_prefix("git+")
+        if local_filesystem_source?(clone_url) && !local_git_repo_path(clone_url)
+          source_root = local_git_source_root(clone_url)
+          if source_root
+            checkouts[source.name] = GitSourceCheckout.new(
+              cache_directory: source_root,
+              revision: "",
+              subdir: source.subdir
+            )
+          end
+          next
+        end
+
+        pinned_revision = refresh ? nil : pinned_revision_for_source(lockfile, source)
+        cache_directory, revision = ensure_git_repository(
+          project_root,
+          clone_url,
+          refresh: refresh,
+          pinned_revision: pinned_revision,
+          sparse_subdir: source.subdir
+        )
+        checkouts[source.name] = GitSourceCheckout.new(
+          cache_directory: cache_directory,
+          revision: revision,
+          subdir: source.subdir
+        )
+      end
+      checkouts
+    end
+
+    def resolve_distribution_root(repo_root, subdir)
+      if subdir
+        path = File.join(repo_root, subdir)
+        return path if local_distribution_root?(path)
+
+        raise Error.resolution(
+          "no pray distribution root at subdir #{path.inspect} in git source #{repo_root.inspect}"
+        )
+      end
+
+      discover_distribution_root(repo_root) ||
+        raise(Error.resolution(
+                "no pray distribution root in git source #{repo_root.inspect}. " \
+                "Expected v1/packages at the repository root or under prayers/. " \
+                "Publish with `pray publish --root ./prayers` or point the source at a distribution repository."
+              ))
+    end
+
+    def discover_distribution_root(path)
+      return path if local_distribution_root?(path)
+
+      prayers_root = File.join(path, "prayers")
+      return prayers_root if local_distribution_root?(prayers_root)
+
+      nil
+    end
+
+    def local_distribution_root?(path)
+      File.directory?(File.join(path, "v1", "packages"))
+    end
+
+    def local_git_source_root(clone_url)
+      path = if clone_url.start_with?("file://")
+        clone_url.delete_prefix("file://")
+      else
+        clone_url
+      end
+      return nil unless File.exist?(path)
+
+      discover_distribution_root(path)
+    end
+
+    def ensure_git_repository(project_root, clone_url, refresh:, pinned_revision:, sparse_subdir:)
+      cache_directory = git_source_cache_directory(project_root, clone_url)
+      if File.directory?(File.join(cache_directory, ".git"))
+        refresh_global_git_cache(clone_url) if refresh
+        if pinned_revision
+          checkout_git_revision(cache_directory, clone_url, pinned_revision, refresh)
+        elsif refresh
+          refresh_git_worktree(cache_directory, clone_url)
+        end
+        apply_sparse_checkout(cache_directory, sparse_subdir) if sparse_subdir
+        revision = git_head_revision(cache_directory)
+        return [cache_directory, revision]
+      end
+
+      FileUtils.rm_rf(cache_directory) if File.exist?(cache_directory)
+      FileUtils.mkdir_p(File.dirname(cache_directory))
+      if seed_git_cache_from_global(clone_url, cache_directory, project_root)
+        run_git_in_repo(cache_directory, "remote", "set-url", "origin", clone_url)
+      else
+        run_git(project_root, "clone", "--depth", "1", clone_url, cache_directory)
+        mirror_git_cache_to_global(clone_url, cache_directory)
+      end
+      checkout_git_revision(cache_directory, clone_url, pinned_revision, true) if pinned_revision
+      apply_sparse_checkout(cache_directory, sparse_subdir) if sparse_subdir
+      [cache_directory, git_head_revision(cache_directory)]
+    end
+
+    def git_source_cache_directory(project_root, clone_url)
+      File.join(project_root, ".pray", "cache", "git", cache_key(clone_url))
+    end
+
+    def cache_key(text)
+      Hashing.sha256_prefixed(text)[7, 16]
+    end
+
+    def pinned_revision_for_source(lockfile, source)
+      if lockfile
+        entry = lockfile.source.find { |item| item.name == source.name && item.kind == "git" }
+        return entry.revision if entry&.revision
+      end
+      return source.rev if source.kind == "git" && source.rev
+
+      source.tag if source.kind == "git"
+    end
+
+    def local_filesystem_source?(clone_url)
+      clone_url.start_with?("file://") || Pathname.new(clone_url).absolute?
+    end
+
+    def local_git_repo_path(clone_url)
+      path = clone_url.delete_prefix("file://")
+      git_directory = File.join(path, ".git")
+      File.directory?(git_directory) ? path : nil
+    end
+
+    def global_cache_root
+      return ENV["PRAY_CACHE"] if ENV["PRAY_CACHE"]
+      return File.join(ENV["PRAY_HOME"], "cache") if ENV["PRAY_HOME"]
+
+      home = ENV["HOME"]
+      home ? File.join(home, ".cache", "pray") : nil
+    end
+
+    def global_git_cache_directory(clone_url)
+      root = global_cache_root
+      root ? File.join(root, "git", cache_key(clone_url)) : nil
+    end
+
+    def global_git_cache_ready?(global_cache)
+      File.directory?(File.join(global_cache, ".git")) || File.file?(File.join(global_cache, "HEAD"))
+    end
+
+    def seed_git_cache_from_global(clone_url, destination, working_directory)
+      global_cache = global_git_cache_directory(clone_url)
+      return false unless global_cache && global_git_cache_ready?(global_cache)
+
+      run_git(working_directory, "clone", "--depth", "1", "--quiet", global_cache, destination)
+      true
+    end
+
+    def mirror_git_cache_to_global(clone_url, project_cache)
+      global_cache = global_git_cache_directory(clone_url)
+      return unless global_cache
+      return if global_git_cache_ready?(global_cache)
+
+      FileUtils.mkdir_p(File.dirname(global_cache))
+      FileUtils.rm_rf(global_cache) if File.exist?(global_cache)
+      run_git(File.dirname(project_cache), "clone", "--bare", "--quiet", File.basename(project_cache), global_cache)
+    end
+
+    def apply_sparse_checkout(repository, subdir)
+      run_git_in_repo(repository, "sparse-checkout", "init", "--cone")
+      run_git_in_repo(repository, "sparse-checkout", "set", subdir)
+    end
+
+    def checkout_git_revision(repository, _clone_url, revision, refresh)
+      run_git_in_repo(repository, "fetch", "--depth", "1", "origin", revision) if refresh
+      run_git_in_repo(repository, "checkout", "--force", revision)
+    end
+
+    def refresh_git_worktree(repository, _clone_url)
+      run_git_in_repo(repository, "fetch", "--depth", "1", "origin")
+      run_git_in_repo(repository, "reset", "--hard", "origin/HEAD")
+    end
+
+    def refresh_global_git_cache(clone_url)
+      global_cache = global_git_cache_directory(clone_url)
+      return unless global_cache && global_git_cache_ready?(global_cache)
+
+      run_git_in_repo(global_cache, "fetch", "--depth", "1", "origin")
+    end
+
+    def git_head_revision(repository)
+      output, status = Open3.capture2e("git", "-C", repository, "rev-parse", "HEAD")
+      raise Error.resolution(command_error("git rev-parse HEAD", output)) unless status.success?
+
+      revision = output.strip
+      raise Error.resolution("git repository has no HEAD revision") if revision.empty?
+
+      revision
+    end
+
+    def run_git(cwd, *arguments)
+      output, status = Open3.capture2e("git", "-C", cwd, *arguments)
+      return if status.success?
+
+      raise Error.resolution(command_error("git #{arguments.join(" ")}", output))
+    end
+
+    def run_git_in_repo(repository, *arguments)
+      run_git(repository, *arguments)
+    end
+
+    def command_error(program, output)
+      message = output.strip
+      message.empty? ? "#{program} failed" : "#{program} failed: #{message}"
+    end
+  end
+end

data/lib/pray/hashing.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "digest"
+require "openssl"
+
+module Pray
+  module Hashing
+    module_function
+
+    def sha256_hex(bytes)
+      Digest::SHA256.hexdigest(bytes)
+    end
+
+    def sha256_prefixed(bytes)
+      prefixed_hex_digest(Digest::SHA256.digest(bytes))
+    end
+
+    def prefixed_hex_digest(digest_bytes)
+      "sha256:#{digest_bytes.unpack1("H*")}"
+    end
+
+    def marker_id(seed)
+      sha256_hex(seed)[0, 8]
+    end
+
+    def normalize_line_endings(text)
+      text.gsub("\r\n", "\n").tr("\r", "\n")
+    end
+
+    def checksum_managed_span_content(body)
+      normalized = normalize_line_endings(body).sub(/\n+\z/, "")
+      sha256_prefixed(normalized)
+    end
+
+    def checksum_managed_body_line_refs(body_lines)
+      lines = trim_trailing_empty_lines(body_lines)
+      digest = OpenSSL::Digest::SHA256.new
+      lines.each_with_index do |line, index|
+        digest << "\n" if index.positive?
+        update_line_endings_normalized(digest, line)
+      end
+      prefixed_hex_digest(digest.digest)
+    end
+
+    def trim_trailing_empty_lines(lines)
+      trimmed = lines.dup
+      trimmed.pop while trimmed.last == ""
+      trimmed
+    end
+
+    def update_line_endings_normalized(digest, line)
+      digest << if line.include?("\r")
+        normalize_line_endings(line)
+      else
+        line
+      end
+    end
+  end
+end

data/lib/pray/invocation.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Pray
+  module Invocation
+    module_function
+
+    def initialize(arguments)
+      options, remaining = parse_global_options(arguments)
+      self.context = ProjectContext.from_options(options)
+      remaining
+    end
+
+    def context
+      Thread.current[:pray_invocation_context]
+    end
+
+    def context=(value)
+      Thread.current[:pray_invocation_context] = value
+    end
+
+    def invocation_context
+      context || ProjectContext.from_current_directory
+    end
+
+    def manifest_path
+      invocation_context.manifest_path
+    end
+
+    def lockfile_path
+      invocation_context.lockfile_path
+    end
+
+    def project_root
+      invocation_context.project_root
+    end
+
+    def resolve_current_project(options = ResolveOptions.new)
+      context = invocation_context
+      resolved_options = options.dup
+      resolved_options.environment ||= context.environment
+      Resolve.resolve_project_in_context(context.manifest_path, context.project_root, resolved_options)
+    end
+
+    def resolve_current_project_with_git_refresh_fallback(options = ResolveOptions.new, allow_git_refresh_fallback: false)
+      resolve_current_project(options)
+    rescue Error => error
+      if allow_git_refresh_fallback &&
+          !options.offline &&
+          !options.refresh &&
+          Resolve.resolution_may_benefit_from_git_source_refresh?(error)
+        refreshed = options.dup
+        refreshed.refresh = true
+        resolve_current_project(refreshed)
+      else
+        raise
+      end
+    end
+
+    def parse_global_options(arguments)
+      options = ProjectInvocationOptions.new
+      remaining = []
+      index = 0
+      while index < arguments.length
+        argument = arguments[index]
+        case argument
+        when "--path"
+          index += 1
+          options.project_root = require_option_value("--path", arguments[index])
+        when "--file-path"
+          index += 1
+          options.manifest_path = require_option_value("--file-path", arguments[index])
+        when "--env", "--environment"
+          index += 1
+          options.environment = require_environment_value(argument, arguments[index])
+        else
+          if top_level_command?(argument) || argument.start_with?("-")
+            remaining.concat(arguments[index..])
+            break
+          end
+          remaining.concat(arguments[index..])
+          break
+        end
+        index += 1
+      end
+      [options, remaining]
+    end
+
+    def require_option_value(flag, value)
+      raise Error.usage("#{flag} requires a value") if value.nil? || value.empty?
+
+      value
+    end
+
+    def require_environment_value(flag, value)
+      raise Error.usage("#{flag} requires a value") if value.nil?
+
+      value
+    end
+
+    def top_level_command?(token)
+      %w[
+        manifest init prayer repo install add remove update unlock render plan apply verify drift
+        format fmt package publish login serve confess list outdated explain vendor clean tree sync trust
+        version -V --version -h --help help
+      ].include?(token)
+    end
+  end
+end