pray-cli 1.21.0 → 1.23.0

data/lib/pray/git_materialize.rb

@@ -5,7 +5,10 @@ require "open3"
 require_relative "error"
 require_relative "git_clone"
 require_relative "git_run"
+require_relative "git_store"
 require_relative "path_safety"
+require_relative "resource_limits"
+require_relative "tar_validation"
 
 module Pray
   module GitMaterialize
@@ -14,56 +17,129 @@ module Pray
 
     module_function
 
-    def read_local_artifact_bytes(source_root, artifact)
-      if artifact.start_with?("file://")
-        path = PathSafety.join_under_root(source_root, artifact.delete_prefix("file://"))
-        raise Error.resolution("package artifact path escapes distribution root") unless path
-
-        return File.binread(path)
-      end
-      if artifact.match?(%r{\A[a-z][a-z0-9+.-]*:}i)
-        raise Error.integrity("remote artifact path must be relative: #{artifact}")
+    def read_local_artifact_bytes(source_root, artifact, offline: false)
+      if artifact.include?("://") || artifact.start_with?("file:")
+        raise Error.integrity(
+          "local and git catalog artifacts must be relative paths under the distribution root, not URLs: #{artifact}"
+        )
       end
 
       path = PathSafety.join_under_root(source_root, artifact)
       raise Error.resolution("package artifact path escapes distribution root") unless path
 
-      materialize_catalog_file(source_root, artifact) unless File.exist?(path)
+      materialize_catalog_file(source_root, artifact, offline: offline) unless File.exist?(path)
       raise Error.resolution("package artifact missing at #{path}") unless File.exist?(path)
 
       File.binread(path)
     end
 
-    def materialize_catalog_tree(git_dir, dest, revision, subdir, refresh)
-      return if !refresh && catalog_matches?(dest, git_dir, revision)
+    def materialize_catalog_tree(git_dir, dest, revision, subdir, refresh, offline: false)
+      require_revision_present!(git_dir, revision, offline: offline)
+      GitStore.with_git_cache_lock(dest) do
+        return if !refresh && catalog_matches?(dest, git_dir, revision)
 
-      FileUtils.rm_rf(dest) if File.exist?(dest)
-      FileUtils.mkdir_p(dest)
-      unpacked = GitClone.catalog_sparse_cones(subdir).any? do |prefix|
-        unpack_archive_prefix(git_dir, dest, revision, prefix)
+        staging = "#{dest}.partial"
+        FileUtils.rm_rf(staging)
+        FileUtils.mkdir_p(staging)
+        unpacked = GitClone.catalog_sparse_cones(subdir).any? do |prefix|
+          unpack_archive_prefix(git_dir, staging, revision, prefix, offline: offline)
+        end
+        unless unpacked
+          FileUtils.rm_rf(staging)
+          if offline
+            raise Error.resolution(
+              "git catalog at revision #{revision} is not materializable locally and offline mode is enabled"
+            )
+          end
+          raise Error.resolution("no pray distribution root in git source at revision #{revision}")
+        end
+
+        File.write(File.join(staging, REVISION_MARKER), revision)
+        File.write(File.join(staging, GIT_DIR_MARKER), git_dir)
+        publish_catalog_tree!(dest, staging)
       end
-      raise Error.resolution("no pray distribution root in git source at revision #{revision}") unless unpacked
+    end
 
-      File.write(File.join(dest, REVISION_MARKER), revision)
-      File.write(File.join(dest, GIT_DIR_MARKER), git_dir)
+    def publish_catalog_tree!(dest, staging)
+      FileUtils.mkdir_p(File.dirname(dest))
+      if File.exist?(dest)
+        backup = "#{dest}.previous"
+        FileUtils.rm_rf(backup)
+        File.rename(dest, backup)
+        begin
+          File.rename(staging, dest)
+        rescue
+          File.rename(backup, dest) if File.exist?(backup)
+          FileUtils.rm_rf(staging)
+          raise
+        end
+        FileUtils.rm_rf(backup)
+      else
+        File.rename(staging, dest)
+      end
     end
+    private_class_method :publish_catalog_tree!
 
-    def materialize_catalog_file(source_root, relative)
-      return if File.file?(File.join(source_root, relative))
+    def materialize_catalog_file(source_root, relative, offline: false)
+      full_path = File.join(source_root, relative)
+      return if File.file?(full_path)
 
       markers = find_catalog_markers(source_root)
       return unless markers
 
-      full_path = File.join(source_root, relative)
-      repo_relative = full_path.delete_prefix(markers.fetch(:work_tree)).delete_prefix("/")
-      GitRun.run_git(
-        markers.fetch(:git_dir),
-        "--work-tree",
-        markers.fetch(:work_tree),
-        "checkout",
-        markers.fetch(:revision),
-        "--",
-        repo_relative
+      GitStore.with_git_cache_lock(markers.fetch(:catalog_root)) do
+        return if File.file?(full_path)
+
+        require_revision_present!(markers.fetch(:git_dir), markers.fetch(:revision), offline: offline)
+        repo_relative = full_path.delete_prefix(markers.fetch(:catalog_root)).delete_prefix("/")
+        object = "#{markers.fetch(:revision)}:#{repo_relative}"
+        require_blob_within_limit!(markers.fetch(:git_dir), object, offline: offline)
+        env = GitRun.git_env(offline_git_env(offline))
+        stdout, status = Open3.capture2(
+          env,
+          "git",
+          "-c",
+          "protocol.file.allow=always",
+          "-C",
+          markers.fetch(:git_dir),
+          "show",
+          object,
+          stdin_data: ""
+        )
+        unless status.success?
+          if offline
+            raise Error.resolution(
+              "git catalog blob #{repo_relative} at revision #{markers.fetch(:revision)} is not available locally and offline mode is enabled"
+            )
+          end
+          annotate_git_materialize_failure!(
+            markers.fetch(:git_dir),
+            markers.fetch(:revision),
+            "git show failed"
+          )
+        end
+        write_catalog_blob_atomic!(full_path, stdout)
+      end
+    end
+
+    def require_revision_present!(git_dir, revision, offline: false)
+      return if GitRun.try_run_git(git_dir, "cat-file", "-e", revision)
+
+      if offline
+        raise Error.resolution(
+          "git revision #{revision} is not available in #{git_dir} and offline mode is enabled (git_revision_unfetched)."
+        )
+      end
+      raise Error.resolution(
+        "git revision #{revision} is not available in #{git_dir} (git_revision_unfetched). " \
+        "Run `pray install --locked`, or clear the project git cache and shared bare then install again."
+      )
+    end
+
+    def annotate_git_materialize_failure!(git_dir, revision, detail)
+      raise Error.resolution(
+        "git catalog materialize failed for revision #{revision} in #{git_dir} (git_cache_stale): #{detail}. " \
+        "Run `pray install --locked`, or clear `.pray/cache/git` and the shared bare then install again."
       )
     end
 
@@ -73,6 +149,7 @@ module Pray
       return false unless File.file?(revision_path) && File.file?(git_dir_path)
       return false unless File.read(revision_path).strip == revision
       return false unless File.read(git_dir_path).strip == git_dir
+      return false unless GitRun.try_run_git(git_dir, "cat-file", "-e", revision)
 
       File.directory?(File.join(dest, "v1", "packages")) ||
         File.directory?(File.join(dest, "prayers", "v1", "packages")) ||
@@ -81,8 +158,10 @@ module Pray
       false
     end
 
-    def unpack_archive_prefix(git_dir, dest, revision, prefix)
-      env = GitRun.git_env("GIT_TERMINAL_PROMPT" => "0")
+    def unpack_archive_prefix(git_dir, dest, revision, prefix, offline: false)
+      return false unless tree_prefix_within_limits?(git_dir, revision, prefix, offline: offline)
+
+      env = GitRun.git_env(offline_git_env(offline).merge("GIT_TERMINAL_PROMPT" => "0"))
       stdout, _stderr, status = Open3.capture3(
         env,
         "git",
@@ -98,13 +177,78 @@ module Pray
         stdin_data: ""
       )
       return false unless status.success? && !stdout.empty?
+      if stdout.bytesize > ResourceLimits::MAX_ARCHIVE_TOTAL_BYTES
+        raise Error.integrity(
+          "git catalog archive exceeds #{ResourceLimits::MAX_ARCHIVE_TOTAL_BYTES} bytes"
+        )
+      end
 
-      _ignored, extract_status = Open3.capture2(env, "tar", "-x", "-C", dest, stdin_data: stdout)
-      raise Error.resolution("failed to unpack git catalog archive") unless extract_status.success?
-
+      TarValidation.extract!(stdout, dest)
       true
     end
 
+    def require_blob_within_limit!(git_dir, object, offline: false)
+      env = GitRun.git_env(offline_git_env(offline))
+      stdout, status = Open3.capture2(
+        env, "git", "-c", "protocol.file.allow=always", "-C", git_dir, "cat-file", "-s", object,
+        stdin_data: ""
+      )
+      return unless status.success?
+
+      size = stdout.strip.to_i
+      return if size <= ResourceLimits::MAX_ARCHIVE_ENTRY_BYTES
+
+      raise Error.integrity(
+        "git catalog blob exceeds #{ResourceLimits::MAX_ARCHIVE_ENTRY_BYTES} bytes"
+      )
+    end
+
+    def tree_prefix_within_limits?(git_dir, revision, prefix, offline: false)
+      env = GitRun.git_env(offline_git_env(offline))
+      stdout, status = Open3.capture2(
+        env, "git", "-c", "protocol.file.allow=always", "-C", git_dir,
+        "ls-tree", "-r", "-l", revision, "--", prefix, stdin_data: ""
+      )
+      return false unless status.success? && !stdout.strip.empty?
+
+      entry_count = 0
+      total_bytes = 0
+      stdout.each_line do |line|
+        parts = line.split
+        next unless parts[1] == "blob"
+
+        size = parts[3].to_i
+        entry_count += 1
+        if entry_count > ResourceLimits::MAX_ARCHIVE_ENTRIES
+          raise Error.integrity(
+            "git catalog archive exceeds #{ResourceLimits::MAX_ARCHIVE_ENTRIES} entries"
+          )
+        end
+        if size > ResourceLimits::MAX_ARCHIVE_ENTRY_BYTES
+          raise Error.integrity(
+            "git catalog archive entry exceeds #{ResourceLimits::MAX_ARCHIVE_ENTRY_BYTES} bytes"
+          )
+        end
+        total_bytes += size
+        if total_bytes > ResourceLimits::MAX_ARCHIVE_TOTAL_BYTES
+          raise Error.integrity(
+            "git catalog archive exceeds #{ResourceLimits::MAX_ARCHIVE_TOTAL_BYTES} bytes"
+          )
+        end
+      end
+      entry_count.positive?
+    end
+
+    def write_catalog_blob_atomic!(full_path, bytes)
+      FileUtils.mkdir_p(File.dirname(full_path))
+      partial = "#{full_path}.partial"
+      File.binwrite(partial, bytes)
+      File.rename(partial, full_path)
+    rescue
+      FileUtils.rm_f(partial)
+      raise
+    end
+
     def find_catalog_markers(start)
       current = start
       8.times do
@@ -113,9 +257,9 @@ module Pray
         if File.file?(revision_path) && File.file?(git_dir_path)
           revision = File.read(revision_path).strip
           git_dir = File.read(git_dir_path).strip
-          return if revision.empty? || !File.exist?(git_dir)
+          return unless acceptable_revision?(revision) && acceptable_shared_bare?(git_dir)
 
-          return {git_dir: git_dir, revision: revision, work_tree: current}
+          return {git_dir: git_dir, revision: revision, catalog_root: current}
         end
         parent = File.dirname(current)
         return if parent == current
@@ -124,5 +268,27 @@ module Pray
       end
       nil
     end
+
+    def acceptable_revision?(revision)
+      return false if revision.empty? || revision.start_with?("-")
+      return false unless [40, 64].include?(revision.length)
+
+      revision.match?(/\A[0-9a-fA-F]+\z/)
+    end
+
+    def acceptable_shared_bare?(git_dir)
+      return false unless File.file?(File.join(git_dir, "HEAD"))
+      return false unless File.directory?(File.join(git_dir, "objects"))
+
+      root = GitStore.global_cache_root
+      return false unless root
+
+      expected = File.join(root, "git")
+      PathSafety.path_under_root?(expected, git_dir)
+    end
+
+    def offline_git_env(offline)
+      offline ? {"GIT_NO_LAZY_FETCH" => "1"} : {}
+    end
   end
 end

data/lib/pray/git_store.rb

@@ -8,27 +8,28 @@ require_relative "git_clone"
 
 module Pray
   module GitStore
+    READY_MARKER = ".pray-ready"
+
     module_function
 
     def ensure_global_git_db(clone_url, pinned_revision:, refresh:, offline:, working_directory:)
       db = global_git_cache_directory(clone_url)
       raise Error.resolution("git object cache is not configured") unless db
 
-      unless global_git_cache_ready?(db)
-        raise Error.resolution(offline_git_source_uncached(clone_url)) if offline
+      with_git_cache_lock(db) do
+        unless global_git_cache_ready?(db)
+          raise Error.resolution(offline_git_source_uncached(clone_url)) if offline
 
-        FileUtils.rm_rf(db) if File.exist?(db)
-        FileUtils.mkdir_p(File.dirname(db))
-        GitClone.clone_bare_git_db(working_directory, clone_url, db, quiet: false)
-        ensure_git_remote_origin(db, clone_url)
-      end
-      fetch_origin_tip(db, clone_url) if refresh && !offline
-      if pinned_revision
-        ensure_revision_in_db(db, clone_url, pinned_revision, !offline)
-        return [db, pinned_revision]
-      end
+          install_bare_clone(working_directory, clone_url, db)
+        end
+        fetch_origin_tip(db, clone_url) if refresh && !offline
+        if pinned_revision
+          ensure_revision_in_db(db, clone_url, pinned_revision, !offline)
+          return [db, pinned_revision]
+        end
 
-      [db, git_head_revision(db)]
+        [db, git_head_revision(db)]
+      end
     end
 
     def global_cache_root
@@ -45,13 +46,98 @@ module Pray
     end
 
     def global_git_cache_ready?(global_cache)
-      File.file?(File.join(global_cache, "HEAD")) || File.directory?(File.join(global_cache, ".git"))
+      return false unless File.file?(File.join(global_cache, "HEAD"))
+      return false unless File.directory?(File.join(global_cache, "objects"))
+      return true if File.file?(File.join(global_cache, READY_MARKER))
+
+      begin
+        git_head_revision(global_cache)
+        true
+      rescue Error
+        false
+      end
+    end
+
+    def mark_git_cache_ready(global_cache)
+      File.write(File.join(global_cache, READY_MARKER), "1")
     end
 
     def offline_git_source_uncached(clone_url)
       "git source #{clone_url} is not cached locally and offline mode is enabled"
     end
 
+    def install_bare_clone(working_directory, clone_url, db)
+      FileUtils.mkdir_p(File.dirname(db))
+      staging = "#{db}.partial"
+      FileUtils.rm_rf(staging) if File.exist?(staging)
+      GitClone.clone_bare_git_db(working_directory, clone_url, staging, quiet: false)
+      ensure_git_remote_origin(staging, clone_url)
+      git_head_revision(staging)
+      mark_git_cache_ready(staging)
+      if File.exist?(db)
+        if global_git_cache_ready?(db)
+          FileUtils.rm_rf(staging)
+          return
+        end
+        FileUtils.rm_rf(db)
+      end
+      FileUtils.mv(staging, db)
+    end
+
+    LOCK_ATTEMPTS = 2_400
+    LOCK_RETRY_SECONDS = 0.025
+    STALE_LOCK_SECONDS = 600
+
+    def with_git_cache_lock(db)
+      lock_directory = "#{db}.lock.d"
+      FileUtils.mkdir_p(File.dirname(lock_directory))
+      acquired = false
+      LOCK_ATTEMPTS.times do
+        Dir.mkdir(lock_directory)
+        write_lock_owner!(lock_directory)
+        acquired = true
+        break
+      rescue Errno::EEXIST
+        clear_stale_lock!(lock_directory)
+        sleep LOCK_RETRY_SECONDS
+      end
+      unless acquired
+        raise Error.resolution(
+          "timed out waiting for git cache lock #{lock_directory}. " \
+          "If no other pray process is using that cache, remove the lock directory and retry."
+        )
+      end
+
+      begin
+        yield
+      ensure
+        FileUtils.rm_rf(lock_directory)
+      end
+    end
+
+    def write_lock_owner!(lock_directory)
+      File.write(File.join(lock_directory, "owner"), "#{Process.pid}\n#{Time.now.to_i}\n")
+    end
+
+    def clear_stale_lock!(lock_directory)
+      age = lock_age_seconds(lock_directory)
+      return if age < STALE_LOCK_SECONDS
+
+      FileUtils.rm_rf(lock_directory)
+    end
+
+    def lock_age_seconds(lock_directory)
+      owner = File.join(lock_directory, "owner")
+      if File.file?(owner)
+        stamp = File.read(owner).lines[1].to_s.strip.to_i
+        return Time.now.to_i - stamp if stamp.positive?
+      end
+      Time.now.to_i - File.mtime(lock_directory).to_i
+    rescue Errno::ENOENT
+      0
+    end
+    private_class_method :write_lock_owner!, :clear_stale_lock!, :lock_age_seconds
+
     def ensure_revision_in_db(db, clone_url, revision, allow_fetch)
       return if GitRun.try_run_git(db, "cat-file", "-e", revision)
       unless allow_fetch
@@ -110,6 +196,7 @@ module Pray
         GitRun.run_git(db, "fetch", "--depth", "1", "origin")
       end
       GitRun.run_git(db, "update-ref", "HEAD", "FETCH_HEAD")
+      mark_git_cache_ready(db)
     end
 
     def fetch_unshallow(db)

data/lib/pray/literal.rb

@@ -81,7 +81,7 @@ module Pray
         when "]", "}", ")"
           depth -= 1
         else
-          return index if depth.zero? && input[index..].start_with?(token)
+          return index if depth.zero? && input[index, token.length] == token
         end
         index += 1
       end
@@ -151,6 +151,7 @@ module Pray
     end
 
     def strip_line_comment(line)
+      return line unless line.include?("#")
       quote = nil
       escaped = false
       line.each_char.with_index do |character, index|
@@ -190,7 +191,7 @@ module Pray
         end
       end
 
-      def peek = remaining[0]
+      def peek = @input[@cursor]
 
       def next_character
         character = peek
@@ -370,9 +371,7 @@ module Pray
         LiteralValue.new(kind: :string, value: @input[start...@cursor])
       end
 
-      def identifier_start?(character)
-        character && (character.match?(/[[:alpha:]]/) || character == "_")
-      end
+      def identifier_start?(character) = character && (character.match?(/[[:alpha:]]/) || character == "_")
 
       def identifier_continue?(character)
         character.match?(%r{[[:alnum:]_\-.\\/]})

data/lib/pray/lockfile_serialize.rb

@@ -144,7 +144,12 @@ module Pray
     end
 
     def format_string(value)
-      escaped = value.gsub("\\", "\\\\").gsub("\"", "\\\"")
+      escapes = {8 => "\\b", 9 => "\\t", 10 => "\\n", 12 => "\\f", 13 => "\\r", 34 => "\\\"", 92 => "\\\\"}
+      escaped = value.each_codepoint.map do |codepoint|
+        escapes.fetch(codepoint) do
+          (codepoint < 32 || codepoint == 127) ? format("\\u%04X", codepoint) : codepoint.chr(Encoding::UTF_8)
+        end
+      end.join
       "\"#{escaped}\""
     end
 

data/lib/pray/manifest_json.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
+require "json"
+
 module Pray
   module ManifestJson
     module_function
 
     def encode_compact(manifest)
-      encode_object(manifest_fields(manifest))
+      JSON.generate(manifest_fields(manifest))
     end
 
     def manifest_fields(manifest)
@@ -109,31 +111,5 @@ module Pray
         "header" => render.header
       }
     end
-
-    def encode_object(hash)
-      entries = hash.map { |key, value| "#{encode_string(key)}:#{encode_value(value)}" }
-      "{#{entries.join(",")}}"
-    end
-
-    def encode_array(array)
-      "[#{array.map { |value| encode_value(value) }.join(",")}]"
-    end
-
-    def encode_value(value)
-      case value
-      when Hash then encode_object(value)
-      when Array then encode_array(value)
-      when String then encode_string(value)
-      when TrueClass, FalseClass then value.to_s
-      when NilClass then "null"
-      when Integer then value.to_s
-      else
-        raise Error.manifest("unsupported JSON value: #{value.inspect}")
-      end
-    end
-
-    def encode_string(text)
-      "\"#{text.gsub("\\", "\\\\").gsub("\"", "\\\"").gsub("\n", "\\n").gsub("\r", "\\r").gsub("\t", "\\t")}\""
-    end
   end
 end

data/lib/pray/manifest_parser.rb

@@ -12,6 +12,10 @@ module Pray
         @cursor = 0
         @group_stack = []
         @surface = StatementSurface::Reader.new
+        @package_indices = {}
+        @local_indices = {}
+        @target_package_names = {}
+        @target_local_paths = {}
       end
 
       def parse_root
@@ -59,7 +63,7 @@ module Pray
         when /\Aagent (.+)\z/
           apply_agent_package(manifest, Regexp.last_match(1))
         when /\Apackage (.+)\z/
-          Destination.upsert_package(manifest, parse_package_with_groups(Regexp.last_match(1)))
+          upsert_package(manifest, parse_package_with_groups(Regexp.last_match(1)))
         when /\A(?:pray|use|include) (.+)\z/
           apply_pray_statement(manifest, Regexp.last_match(1), nil)
         when /\Alocal (.+)\z/
@@ -113,13 +117,13 @@ module Pray
 
       def apply_agent_package(manifest, rest)
         manifest.note_deprecated_keyword("agent")
-        Destination.upsert_package(manifest, parse_package_with_groups(rest))
+        upsert_package(manifest, parse_package_with_groups(rest))
       end
 
       def apply_unbound_local(manifest, rest)
         local = parse_local_decl(rest)
         local.bound = false
-        Destination.upsert_local(manifest, local)
+        upsert_local(manifest, local)
       end
 
       def parse_package_with_groups(rest)
@@ -128,6 +132,24 @@ module Pray
         package
       end
 
+      def upsert_package(manifest, package)
+        Destination.upsert_package(manifest, package, @package_indices)
+      end
+
+      def upsert_local(manifest, local)
+        Destination.upsert_local(manifest, local, @local_indices)
+      end
+
+      def bind_package_entry(target, name)
+        names = (@target_package_names[target.object_id] ||= {})
+        Destination.bind_package_entry(target, name, names)
+      end
+
+      def bind_local_entry(target, path)
+        paths = (@target_local_paths[target.object_id] ||= {})
+        Destination.bind_local_entry(target, path, paths)
+      end
+
       def next_statement
         pending = @surface.next
         return pending if pending

data/lib/pray/manifest_parser_blocks.rb

@@ -33,9 +33,9 @@ module Pray
           return if statement == "end"
           if (match = statement.match(/\Aagent (.+)\z/))
             manifest.note_deprecated_keyword("agent")
-            Destination.upsert_package(manifest, parse_package_with_groups(match[1]))
+            upsert_package(manifest, parse_package_with_groups(match[1]))
           elsif (match = statement.match(/\A(?:package|pray|use|include) (.+)\z/))
-            Destination.upsert_package(manifest, parse_package_with_groups(match[1]))
+            upsert_package(manifest, parse_package_with_groups(match[1]))
           elsif /\Agroup (.+)\z/.match?(statement)
             raise Error.parse("manifest", "nested group blocks are not supported")
           else
@@ -95,8 +95,8 @@ module Pray
       def bind_compose_local(manifest, index, rest)
         local = parse_local_decl(rest)
         local.bound = true
-        Destination.bind_local_entry(manifest.targets[index], local.path)
-        Destination.upsert_local(manifest, local)
+        bind_local_entry(manifest.targets[index], local.path)
+        upsert_local(manifest, local)
       end
 
       def parse_file_block(manifest, rest)
@@ -154,7 +154,7 @@ module Pray
         package.file = file_path
         package.bound = true
         package.roles << "file" unless package.roles.include?("file")
-        Destination.upsert_package(manifest, package)
+        upsert_package(manifest, package)
       end
 
       def apply_pray_statement(manifest, rest, destination_index)
@@ -196,9 +196,9 @@ module Pray
           package.bound = true
           role = Destination.role_for_destination(mode)
           package.roles << role if role && !package.roles.include?(role)
-          Destination.bind_package_entry(manifest.targets[destination_index], package.name)
+          bind_package_entry(manifest.targets[destination_index], package.name)
         end
-        Destination.upsert_package(manifest, package)
+        upsert_package(manifest, package)
       end
 
       def parse_target_block(manifest, target_index)

data/lib/pray/package_spec.rb

@@ -55,6 +55,7 @@ module Pray
     end
 
     def tree_hash_for_root(root)
+      validate_relative_paths!
       file_bytes = {}
       files.each do |file|
         path = File.join(root, file)
@@ -196,7 +197,11 @@ module Pray
         expect_start!
         spec = PackageSpec.new
         while (statement = next_statement)
-          return spec.canonicalized if statement == "end"
+          if statement == "end"
+            package = spec.canonicalized
+            package.validate_relative_paths!
+            return package
+          end
 
           apply_statement(spec, statement)
         end