pray-cli 1.16.0 → 1.18.0

data/lib/pray/registry_http_cache.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Pray
+  module RegistryHttpCache
+    module_function
+
+    def fetch_package_metadata(source_url, package_name)
+      @cache ||= {}
+      key = [source_url, package_name]
+      return @cache[key] if @cache.key?(key)
+
+      PathSafety.reject_unsafe_package_name!(package_name)
+      response = Registry.http_get(Registry.join_url(source_url, "v1/packages/#{package_name}.json"))
+      @cache[key] = Registry.parse_metadata(response)
+    end
+  end
+end

data/lib/pray/render.rb

@@ -3,6 +3,7 @@
 require "fileutils"
 require "pathname"
 require_relative "render_content"
+require_relative "render_managed"
 
 module Pray
   RenderedTarget = Struct.new(:path, :content, :managed_spans) do
@@ -76,7 +77,7 @@ module Pray
 
       (target.entries || []).each do |entry|
         if entry.kind == "local"
-          append_scoped_local(builder, project, entry.path, symbols)
+          append_scoped_local(builder, managed_spans, project, target, output, entry.path, symbols)
         else
           append_scoped_package(builder, managed_spans, project, target, output, entry.name, symbols)
         end
@@ -99,18 +100,17 @@ module Pray
         builder.append_empty_line
       end
       symbols = project.manifest.symbols || {}
+      managed_spans = []
       unbound_locals.each do |local|
         next if local.content.empty? && local.optional
 
         builder.append_line("### #{local.manifest_path}")
-        builder.append_body(Substitute.substitute_pray_symbols(local.content, symbols))
-        builder.append_empty_line
+        append_managed_local(builder, managed_spans, local, target, output, symbols)
       end
 
       builder.append_line("## Shared instructions")
       builder.append_empty_line
 
-      managed_spans = []
       project.packages.each do |package|
         next unless Environment.package_matches_environment?(package.declaration.groups, project.environment)
         next unless Destination.package_bound_to_compose?(package.declaration, target)
@@ -133,13 +133,11 @@ module Pray
       builder.append_empty_line
     end
 
-    def append_scoped_local(builder, project, path, symbols)
+    def append_scoped_local(builder, managed_spans, project, target, output, path, symbols)
       local = project.local_files.find { |candidate| candidate.manifest_path == path }
       return unless local
-      return if local.content.empty? && local.optional
 
-      builder.append_body(Substitute.substitute_pray_symbols(local.content, symbols))
-      builder.append_empty_line
+      append_managed_local(builder, managed_spans, local, target, output, symbols)
     end
 
     def append_scoped_package(builder, managed_spans, project, target, output, package_name, symbols)
@@ -154,34 +152,6 @@ module Pray
       end
     end
 
-    def append_managed_export(builder, managed_spans, package, export, target, output, symbols)
-      body = package.export_bodies[export]
-      unless body
-        raise Error.integrity("compose cannot write binary export #{export}; use file: for unmarked bytes") if package.spec.exports[export]&.kind == "file"
-        raise Error.render("package #{package.declaration.name} is missing cached export #{export}")
-      end
-
-      body = Substitute.substitute_pray_symbols(body, symbols)
-      identifier = Hashing.marker_id("#{package.declaration.name}:#{export}:#{target.name}")
-      open_line = builder.next_line_number
-      builder.append_line("<!-- pray:#{identifier} -->")
-      builder.append_body(body)
-      close_line = builder.next_line_number
-      builder.append_line("<!-- pray:#{identifier} -->")
-      managed_spans << ManagedSpanRecord.new(
-        id: identifier,
-        target: output,
-        open_line: open_line,
-        close_line: close_line,
-        ideal_checksum: Hashing.checksum_managed_span_content(body),
-        package: package.declaration.name,
-        export: export,
-        source_checksum: package.source_checksum,
-        silenced: false
-      )
-      builder.append_empty_line
-    end
-
     def should_inline_export?(package, export_name)
       export = package.spec.exports[export_name]
       export.nil? || %w[fragment file].include?(export.kind)

data/lib/pray/render_managed.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pray
+  module Render
+    module_function
+
+    def append_managed_local(builder, managed_spans, local, target, output, symbols)
+      return if local.content.empty? && local.optional
+
+      body = Substitute.substitute_pray_symbols(local.content, symbols)
+      append_managed_span(
+        builder,
+        managed_spans,
+        "local:#{local.manifest_path}:#{target.name}",
+        body,
+        output,
+        LOCAL_EMBED_PACKAGE,
+        local.manifest_path,
+        local.source_checksum
+      )
+    end
+
+    def append_managed_export(builder, managed_spans, package, export, target, output, symbols)
+      body = package.export_bodies[export]
+      unless body
+        raise Error.integrity("compose cannot write binary export #{export}; use file: for unmarked bytes") if package.spec.exports[export]&.kind == "file"
+        raise Error.render("package #{package.declaration.name} is missing cached export #{export}")
+      end
+
+      body = Substitute.substitute_pray_symbols(body, symbols)
+      append_managed_span(
+        builder,
+        managed_spans,
+        "#{package.declaration.name}:#{export}:#{target.name}",
+        body,
+        output,
+        package.declaration.name,
+        export,
+        package.source_checksum
+      )
+    end
+
+    def append_managed_span(builder, managed_spans, seed, body, output, package, export, source_checksum)
+      identifier = Hashing.marker_id(seed)
+      open_line = builder.next_line_number
+      builder.append_line("<!-- pray:#{identifier} -->")
+      builder.append_body(body)
+      close_line = builder.next_line_number
+      builder.append_line("<!-- pray:#{identifier} -->")
+      managed_spans << ManagedSpanRecord.new(
+        id: identifier,
+        target: output,
+        open_line: open_line,
+        close_line: close_line,
+        ideal_checksum: Hashing.checksum_managed_span_content(body),
+        package: package,
+        export: export,
+        source_checksum: source_checksum,
+        silenced: false
+      )
+      builder.append_empty_line
+    end
+  end
+end

data/lib/pray/render_patch.rb

@@ -7,28 +7,74 @@ module Pray
     def patch_rendered_content(existing, fresh)
       existing_segments = split_segments(existing)
       fresh_segments = split_segments(fresh)
-      fresh_managed = fresh_segments.filter_map do |segment|
-        [segment[:id], segment[:body]] if segment[:kind] == :managed
-      end.to_h
-      overlap = existing_segments.any? do |segment|
-        segment[:kind] == :managed && fresh_managed.key?(segment[:id])
-      end
-      return fresh unless overlap
+      fresh_managed = managed_bodies(fresh_segments)
+      return fresh unless overlapping_managed?(existing_segments, fresh_managed)
 
       used = {}
-      output = existing_segments.map do |segment|
-        next segment[:text] if segment[:kind] == :text
+      output = +""
+      remaining = prepend_new_leading_spans(
+        existing_segments,
+        fresh_segments,
+        managed_id_set(existing_segments),
+        used,
+        output
+      )
+      splice_existing_managed(remaining, fresh_managed, used, output)
+      append_unused_fresh_managed(fresh_segments, used, output)
+      output.end_with?("\n") ? output : "#{output}\n"
+    end
+
+    def managed_bodies(segments)
+      segments.filter_map { |segment| [segment[:id], segment[:body]] if segment[:kind] == :managed }.to_h
+    end
+
+    def overlapping_managed?(existing_segments, fresh_managed)
+      existing_segments.any? { |segment| segment[:kind] == :managed && fresh_managed.key?(segment[:id]) }
+    end
+
+    def managed_id_set(segments)
+      segments.filter_map { |segment| segment[:id] if segment[:kind] == :managed }.to_h { |id| [id, true] }
+    end
+
+    def splice_existing_managed(remaining, fresh_managed, used, output)
+      remaining.each do |segment|
+        if segment[:kind] == :text
+          output << segment[:text]
+          next
+        end
 
         used[segment[:id]] = true
-        managed_segment(segment[:id], fresh_managed.fetch(segment[:id], segment[:body]))
-      end.join
+        output << managed_segment(segment[:id], fresh_managed.fetch(segment[:id], segment[:body]))
+      end
+    end
+
+    def append_unused_fresh_managed(fresh_segments, used, output)
       fresh_segments.each do |segment|
         next unless segment[:kind] == :managed
         next if used[segment[:id]]
 
         output << managed_segment(segment[:id], segment[:body])
       end
-      output.end_with?("\n") ? output : "#{output}\n"
+    end
+
+    def prepend_new_leading_spans(existing_segments, fresh_segments, existing_ids, used, output)
+      missing = fresh_segments.any? { |segment| segment[:kind] == :managed && !existing_ids[segment[:id]] }
+      return existing_segments unless missing
+
+      shared_id = fresh_segments.find { |segment| segment[:kind] == :managed && existing_ids[segment[:id]] }&.[](:id)
+      return existing_segments unless shared_id
+
+      fresh_segments.each do |segment|
+        break if segment[:kind] == :managed && segment[:id] == shared_id
+
+        if segment[:kind] == :text
+          output << segment[:text]
+        else
+          used[segment[:id]] = true
+          output << managed_segment(segment[:id], segment[:body])
+        end
+      end
+      skip_until_managed(existing_segments, shared_id)
     end
 
     def relocate_managed_spans(content, spans)
@@ -68,6 +114,11 @@ module Pray
       segments
     end
 
+    def skip_until_managed(segments, identifier)
+      index = segments.index { |segment| segment[:kind] == :managed && segment[:id] == identifier }
+      index ? segments[index..] : segments
+    end
+
     def lines_of(content)
       content.lines(chomp: true)
     end

data/lib/pray/resolve.rb

@@ -17,7 +17,7 @@ module Pray
   )
 
   ResolvedLocalFile = Struct.new(
-    :path, :manifest_path, :content, :position, :optional
+    :path, :manifest_path, :content, :source_checksum, :position, :optional
   )
 
   module Resolve
@@ -61,7 +61,6 @@ module Pray
         lockfile_hints,
         refresh: options.refresh || options.refresh_source_revisions
       )
-      source_revisions = git_sources.transform_values(&:revision)
       source_host_keys = Trust.prepare_source_host_keys(manifest.sources)
 
       packages = []
@@ -92,6 +91,7 @@ module Pray
       local_files = []
       local_errors = []
       manifest.local.each do |local|
+        next unless Destination.local_compose_embed?(manifest, local)
         local_files << resolve_local_file(project_root, local)
       rescue Error => error
         local_errors << "local #{local.path}: #{error.message}"
@@ -99,6 +99,7 @@ module Pray
       raise Error.resolution(local_errors.join("\n")) unless local_errors.empty?
 
       ResolveDeps.reject_dependency_cycles(packages)
+      source_revisions = git_sources.revisions
 
       ResolvedProject.new(
         manifest_path: manifest_path,
@@ -146,11 +147,6 @@ module Pray
       GitRefresh.resolution_may_benefit_from_git_source_refresh?(error)
     end
 
-    def missing_local_embed_guidance(path)
-      "Prayfile lists `local \"#{path}\"` but the file does not exist. " \
-        "Create the file or remove the entry from Prayfile, then run `pray install`."
-    end
-
     def resolve_package(project_root, sources, git_sources, user_config, declaration, lockfile, offline: false, options: nil)
       options ||= ResolveOptions.new(offline: offline)
       root, registry_latest_version = resolve_package_root_with_metadata(
@@ -164,11 +160,7 @@ module Pray
           "package path #{root.inspect} declares #{spec.name.inspect}, expected #{declaration.name.inspect}"
         )
       end
-      unless Constraint.version_satisfies(spec.version, declaration.constraint)
-        raise Error.resolution(
-          "package #{declaration.name} version #{spec.version} does not satisfy constraint #{declaration.constraint}"
-        )
-      end
+      spec.satisfy_constraint!(declaration.constraint)
 
       selected_exports = select_exports(declaration, spec)
       file_bytes = load_package_file_bytes(root, spec)
@@ -226,7 +218,8 @@ module Pray
 
         case source.kind
         when "path"
-          return [File.join(project_root, source.url, declaration.name.tr("/", "-")), nil]
+          directory = LocalPrayer.path_source_package_directory(source_name, declaration.name)
+          return [File.join(project_root, source.url, directory), nil]
         when "registry", "static index"
           resolved = Registry.resolve_registry_package_root(
             project_root,
@@ -277,30 +270,6 @@ module Pray
       resolve_package_root_with_metadata(project_root, sources, git_sources, user_config, declaration, lockfile).first
     end
 
-    def resolve_local_file(project_root, declaration)
-      path = File.join(project_root, declaration.path)
-      unless File.exist?(path)
-        if declaration.optional
-          return ResolvedLocalFile.new(
-            path: path,
-            manifest_path: declaration.path,
-            content: "",
-            position: declaration.position,
-            optional: true
-          )
-        end
-        raise Error.resolution(missing_local_embed_guidance(declaration.path))
-      end
-
-      ResolvedLocalFile.new(
-        path: path,
-        manifest_path: declaration.path,
-        content: Hashing.normalize_line_endings(File.read(path)),
-        position: declaration.position,
-        optional: declaration.optional
-      )
-    end
-
     def find_prayspec_file(root)
       files = Dir.children(root).filter_map do |entry|
         path = File.join(root, entry)

data/lib/pray/resolve_local.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Pray
+  module Resolve
+    module_function
+
+    def missing_local_embed_guidance(path)
+      "Prayfile lists `local \"#{path}\"` but the file does not exist. " \
+        "Create the file or remove the entry from Prayfile, then run `pray install`."
+    end
+
+    def resolve_local_file(project_root, declaration)
+      path = File.join(project_root, declaration.path)
+      unless File.exist?(path)
+        if declaration.optional
+          return ResolvedLocalFile.new(
+            path: path,
+            manifest_path: declaration.path,
+            content: "",
+            source_checksum: Hashing.sha256_prefixed(""),
+            position: declaration.position,
+            optional: true
+          )
+        end
+        raise Error.resolution(missing_local_embed_guidance(declaration.path))
+      end
+
+      content = Hashing.normalize_line_endings(File.read(path))
+      ResolvedLocalFile.new(
+        path: path,
+        manifest_path: declaration.path,
+        content: content,
+        source_checksum: Hashing.sha256_prefixed(content),
+        position: declaration.position,
+        optional: declaration.optional
+      )
+    end
+  end
+end

data/lib/pray/resolve_source.rb

@@ -10,6 +10,11 @@ module Pray
       namespace = package_namespace(declaration.name)
       return namespace if namespace && sources.key?(namespace)
 
+      unless declaration.name.include?("/")
+        path_sources = sources.select { |_name, source| source.kind == "path" }
+        return path_sources.keys.first if path_sources.length == 1
+      end
+
       case sources.length
       when 0 then nil
       when 1 then sources.keys.first

data/lib/pray/serve.rb

@@ -65,7 +65,7 @@ module Pray
       validate_body_length!(body_length)
       body = body_length.positive? ? socket.read(body_length) : ""
 
-      response = dispatch_request(root, method, path, body)
+      response = dispatch_request(root, method, path, body, headers)
       socket.print(response)
     end
 
@@ -94,7 +94,7 @@ module Pray
       )
     end
 
-    def dispatch_request(root, method, path, body = "")
+    def dispatch_request(root, method, path, body = "", headers = {})
       path = path.split("?", 2).first
 
       case [method, path]
@@ -125,7 +125,8 @@ module Pray
 
       content_type = content_type_for(file_path)
       file_body = File.binread(file_path)
-      ok_response(content_type, file_body)
+      status, ranged_body, content_range = ServeRange.apply(200, file_body, headers["range"])
+      ranged_response(status, content_type, ranged_body, content_range)
     end
 
     def content_type_for(path)
@@ -137,7 +138,17 @@ module Pray
     end
 
     def ok_response(content_type, body)
-      "HTTP/1.1 200 OK\r\nContent-Type: #{content_type}\r\nContent-Length: #{body.bytesize}\r\nConnection: close\r\n\r\n#{body}"
+      ranged_response(200, content_type, body, nil)
+    end
+
+    def ranged_response(status, content_type, body, content_range)
+      reason = {
+        200 => "OK",
+        206 => "Partial Content",
+        416 => "Range Not Satisfiable"
+      }.fetch(status, "OK")
+      range_header = content_range ? "Content-Range: #{content_range}\r\n" : ""
+      "HTTP/1.1 #{status} #{reason}\r\nContent-Type: #{content_type}\r\n#{range_header}Content-Length: #{body.bytesize}\r\nConnection: close\r\n\r\n#{body}"
     end
 
     def html_response(body)

data/lib/pray/serve_range.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pray
+  module ServeRange
+    module_function
+
+    def apply(status, body, range_header)
+      return [status, body, nil] if range_header.nil? || range_header.empty?
+      return [status, body, nil] unless status == 200 && !body.empty?
+
+      start_offset, end_offset = parse_byte_range(range_header, body.bytesize)
+      unless start_offset
+        return [416, "".b, "bytes */#{body.bytesize}"]
+      end
+
+      [
+        206,
+        body.b[start_offset..end_offset],
+        "bytes #{start_offset}-#{end_offset}/#{body.bytesize}"
+      ]
+    end
+
+    def parse_byte_range(header, total)
+      range = header.delete_prefix("bytes=")
+      start_text, end_text = range.split("-", 2)
+      return unless start_text && end_text
+
+      start_offset = Integer(start_text, exception: false)
+      end_offset = Integer(end_text, exception: false)
+      return if start_offset.nil? || end_offset.nil?
+      return unless start_offset <= end_offset && end_offset < total
+
+      [start_offset, end_offset]
+    end
+  end
+end

data/lib/pray/torrent_manifest.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Pray
+  TORRENT_MANIFEST_SPEC = "pray-torrent-v1"
+  DEFAULT_TORRENT_PIECE_SIZE = 16 * 1024
+
+  module TorrentManifest
+    module_function
+
+    def path_for(artifact_path)
+      "#{artifact_path}.praytorrent.json"
+    end
+
+    def payload(name:, version:, artifact_path:, archive_bytes:, trackers: [])
+      {
+        "spec" => TORRENT_MANIFEST_SPEC,
+        "name" => name,
+        "version" => version,
+        "artifact_url" => artifact_path,
+        "artifact_hash" => Hashing.sha256_prefixed(archive_bytes),
+        "piece_size" => DEFAULT_TORRENT_PIECE_SIZE,
+        "length" => archive_bytes.bytesize,
+        "pieces" => piece_hashes(archive_bytes),
+        "sources" => [artifact_path],
+        "trackers" => Array(trackers)
+      }
+    end
+
+    def bytes(name:, version:, artifact_path:, archive_bytes:, trackers: [])
+      JSON.pretty_generate(
+        payload(
+          name: name,
+          version: version,
+          artifact_path: artifact_path,
+          archive_bytes: archive_bytes,
+          trackers: trackers
+        )
+      )
+    end
+
+    def write(root, name:, version:, artifact_path:, archive_bytes:, settings:)
+      return unless settings.allows_torrent?
+
+      path = File.join(root, path_for(artifact_path))
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(
+        path,
+        bytes(
+          name: name,
+          version: version,
+          artifact_path: artifact_path,
+          archive_bytes: archive_bytes,
+          trackers: settings.bootstrap_trackers
+        )
+      )
+    end
+
+    def piece_hashes(archive_bytes)
+      length = archive_bytes.bytesize
+      return [] if length.zero?
+
+      hashes = []
+      start = 0
+      while start < length
+        hashes << Hashing.sha256_prefixed(archive_bytes.byteslice(start, DEFAULT_TORRENT_PIECE_SIZE))
+        start += DEFAULT_TORRENT_PIECE_SIZE
+      end
+      hashes
+    end
+
+    def descriptor_present?(root, artifact_path, settings)
+      !settings.allows_torrent? || File.file?(File.join(root, path_for(artifact_path)))
+    end
+  end
+end

data/lib/pray/upstream_drift.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Pray
+  module Upstream
+    module_function
+
+    def path_fork_drift_lines(project, previous, 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
+      )
+      sources = Resolve.source_map(project.manifest.sources)
+      lines = []
+      project.packages.each do |package|
+        next unless package.declaration.path
+        next unless package.upstream
+
+        upstream = package.upstream
+        resolved = resolve_named(
+          project.project_root, sources, git_sources, user_config, previous, options,
+          upstream.name, "= #{upstream.version}", upstream.source
+        )
+        upstream_content = content_file_bytes(resolved.root, resolved.spec)
+        local_content = local_content_for_refresh(package.root, package.spec)
+        if local_content.empty?
+          lines << "#{package.declaration.name} has no content files; run pray install to copy #{upstream.name} #{upstream.version}"
+          next
+        end
+
+        overlay_file_changes(local_content, upstream_content).each do |path, change|
+          lines << overlay_drift_line(
+            package.declaration.name, upstream.name, upstream.version, path, change
+          )
+        end
+      end
+      lines
+    end
+  end
+end

data/lib/pray/upstream_merge.rb

@@ -76,6 +76,31 @@ module Pray
 
       "= #{new_version}"
     end
+
+    def overlay_file_changes(local_content, upstream_content)
+      (local_content.keys + upstream_content.keys).uniq.sort.filter_map do |path|
+        local = local_content[path]
+        upstream = upstream_content[path]
+        if local && upstream && local != upstream
+          [path, :changed]
+        elsif local && upstream.nil?
+          [path, :local_only]
+        elsif local.nil? && upstream
+          [path, :missing]
+        end
+      end
+    end
+
+    def overlay_drift_line(fork, upstream_name, upstream_version, path, change)
+      case change
+      when :changed
+        "#{fork} #{path} differs from #{upstream_name} #{upstream_version}"
+      when :local_only
+        "#{fork} #{path} local"
+      else
+        "#{fork} #{path} missing from fork"
+      end
+    end
     private_class_method :merge_one_content_path, :merge_all_present
   end
 end