pray-cli 1.20.0 → 1.22.0

data/lib/pray/publish.rb

@@ -4,6 +4,7 @@ require "json"
 require "fileutils"
 require "time"
 require "tmpdir"
+require_relative "terminal"
 
 module Pray
   RegistryIndex = Struct.new(:spec, :packages) do
@@ -15,11 +16,14 @@ module Pray
   module Publish
     module_function
 
-    def publish_to_root(project, root, signer: "local", signer_fingerprint: nil)
+    def publish_to_root(project, root, signer: "local", signer_fingerprint: nil, dest_name: nil, target: nil)
       root = File.expand_path(root)
+      dest_name ||= root
+      target ||= root
       index = load_registry_index(root)
       distribution = Distribution.read_settings(root)
       package_names = index.packages.to_set
+      stats = {published: 0, unchanged: 0}
 
       project.packages.each do |package|
         package.spec.require_release_version!
@@ -31,6 +35,8 @@ module Pray
         if stored_artifact && stored_publish_matches?(stored_artifact, package, existing)
           package_names << package.declaration.name
           write_registry_package_metadata(metadata_path, metadata)
+          report_unchanged(package, dest_name, target)
+          stats[:unchanged] += 1
           next
         end
 
@@ -56,14 +62,20 @@ module Pray
         metadata.versions << version_entry
         write_registry_package_metadata(metadata_path, metadata)
         package_names << package.declaration.name
+        report_published(package, dest_name, target, artifact_path)
+        stats[:published] += 1
       end
 
       index.packages = package_names.sort
       write_registry_index(root, index)
+      stats
     end
 
-    def publish_to_server(project, server_url, signer: "local", signer_fingerprint: nil)
+    def publish_to_server(project, server_url, signer: "local", signer_fingerprint: nil, dest_name: nil, target: nil)
+      dest_name ||= server_url
+      target ||= server_url
       distribution = Distribution.fetch_settings(server_url)
+      stats = {published: 0, unchanged: 0}
       project.packages.each do |package|
         archive_bytes = Archive.build_package_archive_bytes(package)
         artifact_path = registry_artifact_path(package.declaration.name, package.spec.version)
@@ -99,9 +111,38 @@ module Pray
           "application/json",
           JSON.pretty_generate(metadata_to_hash(metadata))
         )
+        report_published(package, dest_name, target, artifact_path)
+        stats[:published] += 1
       end
+      stats
     end
 
+    def report_published(package, dest_name, target, artifact_path)
+      Terminal.println_stdout(
+        "published #{package.declaration.name} #{package.spec.version} -> #{redact_publish_target(dest_name)} (#{redact_publish_target(target)})"
+      )
+      Terminal.println_verbose("  artifact #{artifact_path}")
+    end
+
+    def report_unchanged(package, dest_name, target)
+      Terminal.println_stdout(
+        "unchanged #{package.declaration.name} #{package.spec.version} -> #{redact_publish_target(dest_name)} (#{redact_publish_target(target)})"
+      )
+      Terminal.println_verbose("  skip reason: stored publish matches")
+    end
+
+    def redact_publish_target(target)
+      text = target.to_s
+      return text unless text.include?("://")
+
+      scheme, remainder = text.split("://", 2)
+      return text unless remainder&.include?("@")
+
+      _userinfo, host_and_path = remainder.split("@", 2)
+      "#{scheme}://***@#{host_and_path}"
+    end
+    private_class_method :report_published, :report_unchanged
+
     def published_registry_package_version(package, signer, signer_fingerprint, archive_bytes, artifact_path)
       RegistryPackageVersion.new(
         version: package.spec.version,
@@ -114,7 +155,8 @@ module Pray
         signer: signer,
         signer_fingerprint: signer_fingerprint,
         published_at: Time.now.to_i,
-        signature: Registry.registry_artifact_signature(archive_bytes, package.tree_hash, signer)
+        signature: Registry.registry_artifact_signature(archive_bytes, package.tree_hash, signer),
+        derived_metadata: DerivedMetadata.from_package_root(package.root, package.spec)
       )
     end
 
@@ -163,6 +205,7 @@ module Pray
 
       version_entry.yanked = existing.yanked
       version_entry.published_at = existing.published_at if stored_artifact
+      version_entry.derived_metadata ||= existing.derived_metadata
     end
 
     def load_registry_index(root)
@@ -181,7 +224,7 @@ module Pray
 
     def load_registry_package_metadata(path, package_name)
       if File.exist?(path)
-        data = JSON.parse(File.read(path))
+        data = JSON.parse(File.read(path, encoding: "UTF-8"))
         RegistryPackageMetadata.new(
           name: data["name"],
           versions: Array(data["versions"]).map { |entry| Registry.version_from_hash(entry) }
@@ -193,7 +236,7 @@ module Pray
 
     def write_registry_package_metadata(path, metadata)
       FileUtils.mkdir_p(File.dirname(path))
-      File.write(path, JSON.pretty_generate(metadata_to_hash(metadata)))
+      File.write(path, JSON.pretty_generate(metadata_to_hash(metadata)), encoding: "UTF-8")
     end
 
     def metadata_to_hash(metadata)
@@ -217,6 +260,7 @@ module Pray
       hash["signer_fingerprint"] = entry.signer_fingerprint if entry.signer_fingerprint
       hash["published_at"] = entry.published_at if entry.published_at
       hash["signature"] = entry.signature if entry.signature
+      hash["derived_metadata"] = entry.derived_metadata if entry.derived_metadata
       hash
     end
 

data/lib/pray/registry.rb

@@ -15,15 +15,17 @@ require_relative "git_materialize"
 module Pray
   RegistryPackageVersion = Struct.new(
     :version, :artifact, :artifact_hash, :tree_hash, :yanked, :targets, :exports,
-    :signer, :signer_fingerprint, :published_at, :signature
+    :signer, :signer_fingerprint, :published_at, :signature, :derived_metadata
   ) do
     def initialize(
       artifact_hash: nil, tree_hash: nil, yanked: false, targets: [], exports: [],
-      signer: nil, signer_fingerprint: nil, published_at: nil, signature: nil, **kwargs
+      signer: nil, signer_fingerprint: nil, published_at: nil, signature: nil,
+      derived_metadata: nil, **kwargs
     )
       super(**kwargs, artifact_hash: artifact_hash, tree_hash: tree_hash, yanked: yanked,
                       targets: targets, exports: exports, signer: signer,
-                      signer_fingerprint: signer_fingerprint, published_at: published_at, signature: signature)
+                      signer_fingerprint: signer_fingerprint, published_at: published_at,
+                      signature: signature, derived_metadata: derived_metadata)
     end
   end
 
@@ -118,7 +120,7 @@ module Pray
 
       raise Error.resolution(offline_package_error(declaration.name, selected.version)) if offline
 
-      artifact_bytes = read_local_artifact_bytes(source_root, selected.artifact)
+      artifact_bytes = read_local_artifact_bytes(source_root, selected.artifact, offline: offline)
       RegistryInstall.install_artifact_to_cache(
         cache_directory, declaration, selected, artifact_bytes, source_url: source_root
       )
@@ -159,15 +161,16 @@ module Pray
         signer: entry["signer"],
         signer_fingerprint: entry["signer_fingerprint"],
         published_at: entry.key?("published_at") ? publish_timestamp_from_value(entry["published_at"]) : nil,
-        signature: entry["signature"]
+        signature: entry["signature"],
+        derived_metadata: entry["derived_metadata"]
       )
     end
 
     def publish_timestamp_from_value(value)
       timestamp = case value
+      when nil then return nil
       when Integer then value
-      when String
-        value.match?(/\A\d+\z/) ? value.to_i : Time.iso8601(value).to_i
+      when String then value.match?(/\A\d+\z/) ? value.to_i : Time.iso8601(value).to_i
       end
       unless timestamp&.between?(0, 253_402_300_799)
         raise Error.integrity("registry published_at must be whole UTC Unix seconds")
@@ -206,8 +209,8 @@ module Pray
       Gem::Version.new(left) <=> Gem::Version.new(right)
     end
 
-    def read_local_artifact_bytes(source_root, artifact)
-      GitMaterialize.read_local_artifact_bytes(source_root, artifact)
+    def read_local_artifact_bytes(source_root, artifact, offline: false)
+      GitMaterialize.read_local_artifact_bytes(source_root, artifact, offline: offline)
     end
 
     def read_artifact_bytes(source_url, artifact)

data/lib/pray/sync.rb

@@ -205,10 +205,7 @@ module Pray
     end
 
     def fetch_bytes(peer_source, artifact)
-      if artifact.start_with?("http://", "https://")
-        return Registry.http_get(artifact).b
-      end
-
+      Registry.reject_absolute_artifact!(artifact)
       Registry.http_get("#{trim_slash(peer_source)}/#{artifact.delete_prefix("/")}").b
     end
 

data/lib/pray/tar_validation.rb

@@ -38,6 +38,8 @@ module Pray
 
     def process_entry(header, data, size, state, output_directory)
       type = header.byteslice(156, 1)
+      # git archive emits a pax global header (`g`); ignore without applying path.
+      return if type == "g"
       if type == "x"
         state.pending_path = pax_path(data)
         return

data/lib/pray/terminal.rb

@@ -20,6 +20,34 @@ module Pray
       env_truthy?("PRAY_NO_INPUT")
     end
 
+    def quiet?
+      env_truthy?("PRAY_QUIET")
+    end
+
+    def verbose?
+      level = ENV.fetch("PRAY_VERBOSE", "0").to_i
+      level > 0
+    end
+
+    def configure_output!(quiet:, verbose:)
+      ENV["PRAY_QUIET"] = "1" if quiet
+      if verbose > 0
+        ENV["PRAY_VERBOSE"] = verbose.to_s
+      end
+    end
+
+    def println_stdout(message)
+      return if quiet?
+
+      puts message
+    end
+
+    def println_verbose(message)
+      return if quiet? || !verbose?
+
+      puts message
+    end
+
     def env_truthy?(name)
       value = ENV.fetch(name, nil)
       return false if value.nil?

data/lib/pray/trust_ops.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require_relative "git_run"
 
 module Pray
   module Trust
@@ -189,7 +190,7 @@ module Pray
 
     def git_format(repository, format)
       output = IO.popen(
-        ["git", "-C", repository, "log", "-1", "--format=#{format}"],
+        [GitRun.git_env, "git", "-C", repository, "log", "-1", "--format=#{format}"],
         err: File::NULL, &:read
       )
       return "" unless $?.success?

data/lib/pray/upstream_merge.rb

@@ -39,13 +39,15 @@ module Pray
       when [false, true, false]
         (local == old) ? :omit : :conflict
       when [false, false, true]
-        (old == new) ? :omit : new
+        (old == new) ? :omit : :conflict
       when [true, false, true]
         new
       when [true, true, false]
         local
       when [true, false, false]
         (local == new) ? new : :conflict
+      when [false, true, true]
+        :omit
       else
         :conflict
       end
@@ -67,7 +69,9 @@ module Pray
 
     def merge_conflict_message(fork, upstream_name, old_version, new_version, paths)
       "upstream merge conflict in #{fork} while refreshing #{upstream_name} " \
-        "#{old_version} to #{new_version}: #{paths.join(", ")}"
+        "#{old_version} to #{new_version}: #{paths.join(", ")}. " \
+        "Reset those content files to the locked upstream tree, run `pray update --latest`, " \
+        "re-apply intentional overlays, then bump the fork version (upstream_merge_conflict)."
     end
 
     def next_upstream_constraint(current, new_version)

data/lib/pray/upstream_plan.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Pray
+  module Upstream
+    PathUpstreamConflict = Struct.new(
+      :package_name,
+      :upstream_name,
+      :old_version,
+      :new_version,
+      :paths,
+      keyword_init: true
+    )
+
+    module_function
+
+    def plan_path_upstream_conflicts(project, previous, selected, options)
+      user_config = Config.load_user_config
+      git_sources = GitSources.prepare_git_sources(
+        project.project_root,
+        project.manifest.sources,
+        previous,
+        refresh: options.refresh || options.refresh_source_revisions,
+        offline: options.offline
+      )
+      sources = Resolve.source_map(project.manifest.sources)
+      conflicts = []
+      project.packages.each do |package|
+        next if selected && package.declaration.name != selected
+
+        conflict = plan_one_path_upstream_conflict(
+          project, package, previous, sources, git_sources, user_config, options
+        )
+        conflicts << conflict if conflict
+      end
+      conflicts
+    end
+
+    def report_path_upstream_would_conflicts(project, previous, selected, options)
+      conflicts = plan_path_upstream_conflicts(project, previous, selected, options)
+      return if conflicts.empty?
+
+      messages = conflicts.map do |conflict|
+        puts "would-conflict #{conflict.package_name}: #{conflict.paths.join(", ")}"
+        merge_conflict_message(
+          conflict.package_name,
+          conflict.upstream_name,
+          conflict.old_version,
+          conflict.new_version,
+          conflict.paths
+        )
+      end
+      raise Error.resolution(messages.join("\n"))
+    end
+
+    def plan_one_path_upstream_conflict(project, package, previous, sources, git_sources, user_config, options)
+      new_upstream = package.upstream
+      return nil unless new_upstream && package.declaration.path
+
+      local_content = local_content_for_refresh(package.root, package.spec)
+      return nil if local_content.empty?
+
+      old_upstream = previous&.package&.find { |entry| entry.name == package.declaration.name }&.upstream
+      return nil unless old_upstream
+      return nil if old_upstream.version == new_upstream.version && old_upstream.tree_hash == new_upstream.tree_hash
+
+      old_package, new_package = resolve_upstream_pair(
+        project, previous, sources, git_sources, user_config, options, old_upstream, new_upstream
+      )
+      old_content = content_file_bytes(old_package.root, old_package.spec)
+      new_content = content_file_bytes(new_package.root, new_package.spec)
+      _merged, conflict_paths = try_merge_content_files(old_content, new_content, local_content)
+      return nil if conflict_paths.empty?
+
+      PathUpstreamConflict.new(
+        package_name: package.declaration.name,
+        upstream_name: old_upstream.name,
+        old_version: old_upstream.version,
+        new_version: new_upstream.version,
+        paths: conflict_paths
+      )
+    end
+    private_class_method :plan_one_path_upstream_conflict
+  end
+end

data/lib/pray/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module Pray
-  VERSION = "1.20.0"
-  GENERATED_BY = "pray 1.20.0"
+  VERSION = "1.22.0"
+  GENERATED_BY = "pray 1.22.0"
 end

data/lib/pray.rb

@@ -13,6 +13,7 @@ require_relative "pray/manifest"
 require_relative "pray/format_serialize"
 require_relative "pray/format_manifest"
 require_relative "pray/package_spec"
+require_relative "pray/package_spec_paths"
 require_relative "pray/package_spec_version"
 require_relative "pray/local_prayer"
 require_relative "pray/lockfile"
@@ -38,6 +39,7 @@ require_relative "pray/upstream"
 require_relative "pray/upstream_merge"
 require_relative "pray/package_spec_render"
 require_relative "pray/upstream_refresh"
+require_relative "pray/upstream_plan"
 require_relative "pray/upstream_drift"
 require_relative "pray/upstream_latest"
 require_relative "pray/compose_dest"
@@ -57,6 +59,7 @@ require_relative "pray/http_body"
 require_relative "pray/registry_install"
 require_relative "pray/registry_integrity"
 require_relative "pray/registry"
+require_relative "pray/derived_metadata"
 require_relative "pray/archive_unpack"
 require_relative "pray/archive"
 require_relative "pray/plan"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pray-cli
 version: !ruby/object:Gem::Version
-  version: 1.20.0
+  version: 1.22.0
 platform: ruby
 authors:
 - Andrei Makarov
@@ -129,6 +129,7 @@ files:
 - lib/pray/config.rb
 - lib/pray/constraint.rb
 - lib/pray/dependency_graph.rb
+- lib/pray/derived_metadata.rb
 - lib/pray/destination.rb
 - lib/pray/distribution.rb
 - lib/pray/dotenv.rb
@@ -138,6 +139,7 @@ files:
 - lib/pray/format_serialize.rb
 - lib/pray/git_cache.rb
 - lib/pray/git_clone.rb
+- lib/pray/git_legacy.rb
 - lib/pray/git_materialize.rb
 - lib/pray/git_refresh.rb
 - lib/pray/git_run.rb
@@ -160,6 +162,7 @@ files:
 - lib/pray/manifest_parser_publish.rb
 - lib/pray/materialize.rb
 - lib/pray/package_spec.rb
+- lib/pray/package_spec_paths.rb
 - lib/pray/package_spec_render.rb
 - lib/pray/package_spec_version.rb
 - lib/pray/path_safety.rb
@@ -209,6 +212,7 @@ files:
 - lib/pray/upstream_drift.rb
 - lib/pray/upstream_latest.rb
 - lib/pray/upstream_merge.rb
+- lib/pray/upstream_plan.rb
 - lib/pray/upstream_refresh.rb
 - lib/pray/verify.rb
 - lib/pray/verify_locked_dest.rb
@@ -240,7 +244,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Package manager for the language placed before inference (Prayfile)
 test_files: []