pray-cli 1.16.0 → 1.17.0

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
@@ -92,6 +92,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}"
@@ -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

data/lib/pray/upstream_refresh.rb

@@ -27,6 +27,11 @@ module Pray
       new_upstream = package.upstream
       return false unless new_upstream && package.declaration.path
 
+      local_content = local_content_for_refresh(package.root, package.spec)
+      if local_content.empty?
+        return materialize_empty_path_fork(project, package, previous, sources, git_sources, user_config, options, new_upstream)
+      end
+
       old_upstream = previous&.package&.find { |entry| entry.name == package.declaration.name }&.upstream
       return false unless old_upstream
       return false if old_upstream.version == new_upstream.version && old_upstream.tree_hash == new_upstream.tree_hash
@@ -40,6 +45,27 @@ module Pray
       true
     end
 
+    def materialize_empty_path_fork(project, package, previous, sources, git_sources, user_config, options, new_upstream)
+      new_package = resolve_named(
+        project.project_root, sources, git_sources, user_config, previous, options,
+        new_upstream.name, "= #{new_upstream.version}", new_upstream.source
+      )
+      new_content = content_file_bytes(new_package.root, new_package.spec)
+      write_content_files(package.root, {}, new_content)
+      write_refreshed_spec(package, new_package, {}, {}, new_content)
+      true
+    end
+
+    def local_content_for_refresh(root, spec)
+      paths = content_paths(spec.files)
+      return {} if paths.empty?
+
+      missing = paths.count { |relative| !File.file?(File.join(root, relative)) }
+      return {} if missing == paths.length
+
+      content_file_bytes(root, spec)
+    end
+
     def resolve_upstream_pair(project, previous, sources, git_sources, user_config, options, old_upstream, new_upstream)
       old_package = resolve_named(
         project.project_root, sources, git_sources, user_config, previous, options,
@@ -80,7 +106,6 @@ module Pray
       updated = PackageSpecRender.fork_spec_after_refresh(
         package.spec,
         new_package.spec,
-        File.basename(spec_path),
         clean_replica?(old_content, local_content),
         merged.keys
       )
@@ -138,7 +163,8 @@ module Pray
         Transaction.write_file(File.join(root, relative), bytes)
       end
     end
-    private_class_method :apply_one_path_upstream, :resolve_upstream_pair, :merge_fork_content,
+    private_class_method :apply_one_path_upstream, :materialize_empty_path_fork, :local_content_for_refresh,
+      :resolve_upstream_pair, :merge_fork_content,
       :write_refreshed_spec, :resolve_named
   end
 end

data/lib/pray/verify.rb

@@ -83,10 +83,10 @@ module Pray
               message: "Package `#{package.declaration.name}` no longer matches the locked tree hash. Run `pray install` to re-resolve packages."
             )
           end
-          if locked.version != package.spec.version
+          if locked.version != package.spec.recorded_version
             report.findings << VerificationFinding.new(
               kind: "verify_error",
-              message: "Package `#{package.declaration.name}` resolved to version #{package.spec.version} but `Prayfile.lock` has #{locked.version}. Run `pray install` to refresh the lockfile."
+              message: "Package `#{package.declaration.name}` resolved to version #{package.spec.recorded_version} but `Prayfile.lock` has #{locked.version}. Run `pray install` to refresh the lockfile."
             )
           end
         else

data/lib/pray/version.rb

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

data/lib/pray.rb

@@ -13,7 +13,13 @@ require_relative "pray/manifest"
 require_relative "pray/format_serialize"
 require_relative "pray/format_manifest"
 require_relative "pray/package_spec"
+require_relative "pray/package_spec_version"
+require_relative "pray/local_prayer"
 require_relative "pray/lockfile"
+require_relative "pray/distribution"
+require_relative "pray/torrent_manifest"
+require_relative "pray/serve_range"
+require_relative "pray/apply_report"
 require_relative "pray/config"
 require_relative "pray/dotenv"
 require_relative "pray/project_context"
@@ -27,13 +33,17 @@ require_relative "pray/resolve_tarball"
 require_relative "pray/invocation"
 require_relative "pray/git_refresh"
 require_relative "pray/resolve"
+require_relative "pray/resolve_local"
 require_relative "pray/upstream"
 require_relative "pray/upstream_merge"
 require_relative "pray/package_spec_render"
 require_relative "pray/upstream_refresh"
+require_relative "pray/upstream_drift"
 require_relative "pray/upstream_latest"
 require_relative "pray/compose_dest"
 require_relative "pray/render_patch"
+require_relative "pray/render_content"
+require_relative "pray/render_managed"
 require_relative "pray/render"
 require_relative "pray/render_dest"
 require_relative "pray/transaction"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pray-cli
 version: !ruby/object:Gem::Version
-  version: 1.16.0
+  version: 1.17.0
 platform: ruby
 authors:
 - Andrei Makarov
@@ -102,6 +102,7 @@ files:
 - bin/pray
 - lib/pray-cli.rb
 - lib/pray.rb
+- lib/pray/apply_report.rb
 - lib/pray/archive.rb
 - lib/pray/archive_unpack.rb
 - lib/pray/auth_client.rb
@@ -110,6 +111,8 @@ files:
 - lib/pray/cli/commands/auth.rb
 - lib/pray/cli/commands/distribution.rb
 - lib/pray/cli/commands/init.rb
+- lib/pray/cli/commands/init_prayer.rb
+- lib/pray/cli/commands/init_prayer_manifest.rb
 - lib/pray/cli/commands/meta.rb
 - lib/pray/cli/commands/packages.rb
 - lib/pray/cli/commands/trust.rb
@@ -127,6 +130,7 @@ files:
 - lib/pray/constraint.rb
 - lib/pray/dependency_graph.rb
 - lib/pray/destination.rb
+- lib/pray/distribution.rb
 - lib/pray/dotenv.rb
 - lib/pray/environment.rb
 - lib/pray/error.rb
@@ -138,6 +142,7 @@ files:
 - lib/pray/http_body.rb
 - lib/pray/invocation.rb
 - lib/pray/literal.rb
+- lib/pray/local_prayer.rb
 - lib/pray/lockfile.rb
 - lib/pray/lockfile_serialize.rb
 - lib/pray/manifest.rb
@@ -150,6 +155,7 @@ files:
 - lib/pray/materialize.rb
 - lib/pray/package_spec.rb
 - lib/pray/package_spec_render.rb
+- lib/pray/package_spec_version.rb
 - lib/pray/path_safety.rb
 - lib/pray/plan.rb
 - lib/pray/project_context.rb
@@ -162,16 +168,19 @@ files:
 - lib/pray/render_content.rb
 - lib/pray/render_dest.rb
 - lib/pray/render_layout.rb
+- lib/pray/render_managed.rb
 - lib/pray/render_patch.rb
 - lib/pray/resolve.rb
 - lib/pray/resolve_context.rb
 - lib/pray/resolve_deps.rb
 - lib/pray/resolve_exports.rb
+- lib/pray/resolve_local.rb
 - lib/pray/resolve_source.rb
 - lib/pray/resolve_tarball.rb
 - lib/pray/resource_limits.rb
 - lib/pray/serve.rb
 - lib/pray/serve_federation.rb
+- lib/pray/serve_range.rb
 - lib/pray/session.rb
 - lib/pray/ssh_agent.rb
 - lib/pray/statement_surface.rb
@@ -179,6 +188,7 @@ files:
 - lib/pray/sync.rb
 - lib/pray/tar_validation.rb
 - lib/pray/terminal.rb
+- lib/pray/torrent_manifest.rb
 - lib/pray/transaction.rb
 - lib/pray/transaction/journal.rb
 - lib/pray/transaction/owner.rb
@@ -187,6 +197,7 @@ files:
 - lib/pray/trust_feed.rb
 - lib/pray/trust_ops.rb
 - lib/pray/upstream.rb
+- lib/pray/upstream_drift.rb
 - lib/pray/upstream_latest.rb
 - lib/pray/upstream_merge.rb
 - lib/pray/upstream_refresh.rb