pray-cli 1.15.0 → 1.17.0

data/lib/pray/registry_paths.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module Pray
+  module RegistryPaths
+    module_function
+
+    def local_registry_root(project_root, source_url)
+      path = source_url.delete_prefix("file://")
+      Pathname.new(path).absolute? ? path : File.expand_path(path, project_root)
+    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
@@ -92,12 +92,15 @@ 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}"
       end
       raise Error.resolution(local_errors.join("\n")) unless local_errors.empty?
 
+      ResolveDeps.reject_dependency_cycles(packages)
+
       ResolvedProject.new(
         manifest_path: manifest_path,
         project_root: project_root,
@@ -144,15 +147,10 @@ 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(
-        project_root, sources, git_sources, user_config, declaration, lockfile, offline: options.offline
+        project_root, sources, git_sources, user_config, declaration, lockfile, options
       )
       spec_path = find_prayspec_file(root)
       spec_text = File.read(spec_path)
@@ -162,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)
@@ -194,12 +188,16 @@ module Pray
     end
 
     def resolve_package_root_with_metadata(
-      project_root, sources, git_sources, user_config, declaration, lockfile, offline: false
+      project_root, sources, git_sources, user_config, declaration, lockfile, options = nil
     )
+      options ||= ResolveOptions.new
+      offline = options.offline
+      preferred_version = options.preferred_lock_version(lockfile, declaration.name)
       if (local_path = user_config.local.package[declaration.name])
         return [File.expand_path(local_path, project_root), nil]
       end
       return [File.expand_path(declaration.path, project_root), nil] if declaration.path
+      return [ResolveTarball.package_root(project_root, declaration.tarball, offline: offline), nil] if declaration.tarball
       source_name = ResolveSource.implied_source_name(declaration, sources)
       if source_name
         source = sources[source_name]
@@ -212,7 +210,7 @@ module Pray
             "local:#{source_name}",
             source_root,
             declaration,
-            preferred_version: lockfile_preferred_version(lockfile, declaration.name),
+            preferred_version: preferred_version,
             offline: offline
           )
           return [resolved.root, resolved.registry_latest_version]
@@ -220,13 +218,14 @@ 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,
             source.url,
             declaration,
-            preferred_version: lockfile_preferred_version(lockfile, declaration.name),
+            preferred_version: preferred_version,
             offline: offline
           )
           return [resolved.root, resolved.registry_latest_version]
@@ -245,7 +244,7 @@ module Pray
               source_key,
               distribution_root,
               declaration,
-              preferred_version: lockfile_preferred_version(lockfile, declaration.name),
+              preferred_version: preferred_version,
               offline: offline
             )
           rescue Error => error
@@ -262,9 +261,7 @@ module Pray
         end
       end
 
-      if declaration.git || declaration.tarball || declaration.oci
-        raise Error.unsupported("remote sources are not implemented yet")
-      end
+      raise Error.unsupported("remote sources are not implemented yet") if declaration.git || declaration.oci
 
       [File.join(project_root, declaration.name.tr("/", "-")), nil]
     end
@@ -273,36 +270,6 @@ module Pray
       resolve_package_root_with_metadata(project_root, sources, git_sources, user_config, declaration, lockfile).first
     end
 
-    def lockfile_preferred_version(lockfile, package_name)
-      return nil unless lockfile
-
-      lockfile.package.find { |entry| entry.name == package_name }&.version
-    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_context.rb

@@ -15,5 +15,12 @@ module Pray
     )
       super
     end
+
+    def preferred_lock_version(lockfile, package_name)
+      return nil unless lockfile
+      return nil if ignore_locked_versions || unlocked_packages.include?(package_name)
+
+      lockfile.package.find { |entry| entry.name == package_name }&.version
+    end
   end
 end

data/lib/pray/resolve_deps.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pray
+  module ResolveDeps
+    module_function
+
+    def reject_dependency_cycles(packages)
+      edges = {}
+      packages.each do |package|
+        edges[package.declaration.name] = package.spec.dependencies.map(&:name)
+      end
+      cycle = DependencyGraph.find_dependency_cycle(edges)
+      return unless cycle
+
+      raise Error.resolution("dependency cycle detected: #{cycle.join(" -> ")}")
+    end
+  end
+end

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/resolve_tarball.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "pathname"
+require_relative "archive_unpack"
+require_relative "hashing"
+require_relative "resource_limits"
+
+module Pray
+  module ResolveTarball
+    module_function
+
+    def package_root(project_root, tarball, offline:)
+      artifact_bytes = read_tarball_bytes(project_root, tarball, offline: offline)
+      if artifact_bytes.bytesize > ResourceLimits::MAX_ARCHIVE_TOTAL_BYTES
+        raise Error.integrity(
+          "package archive exceeds #{ResourceLimits::MAX_ARCHIVE_TOTAL_BYTES} bytes"
+        )
+      end
+
+      cache_key = Hashing.sha256_prefixed(artifact_bytes).delete_prefix("sha256:")[0, 16]
+      cache_directory = File.join(project_root, ".pray", "cache", "tarball", cache_key)
+      if File.directory?(cache_directory)
+        begin
+          Resolve.find_prayspec_file(cache_directory)
+          return cache_directory
+        rescue Error
+          nil
+        end
+      end
+
+      staging_directory = "#{cache_directory}.staging"
+      FileUtils.rm_rf(staging_directory)
+      FileUtils.mkdir_p(staging_directory)
+      ArchiveUnpack.unpack_praypkg(artifact_bytes, staging_directory)
+      Resolve.find_prayspec_file(staging_directory)
+      FileUtils.mkdir_p(File.dirname(cache_directory))
+      FileUtils.rm_rf(cache_directory)
+      FileUtils.mv(staging_directory, cache_directory)
+      cache_directory
+    end
+
+    def read_tarball_bytes(project_root, tarball, offline:)
+      if tarball.start_with?("http://", "https://")
+        if offline
+          raise Error.resolution(
+            "tarball #{tarball} is not cached locally and offline mode is enabled"
+          )
+        end
+        return Registry.http_get(tarball)
+      end
+
+      path = local_tarball_path(project_root, tarball)
+      unless File.file?(path)
+        raise Error.resolution("tarball missing at #{path}")
+      end
+
+      File.binread(path)
+    end
+
+    def local_tarball_path(project_root, tarball)
+      path = tarball.delete_prefix("file://")
+      Pathname.new(path).absolute? ? path : File.expand_path(path, project_root)
+    end
+  end
+end

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