pray-cli 1.6.0

data/lib/pray/literal.rb

@@ -0,0 +1,382 @@
+# frozen_string_literal: true
+
+module Pray
+  module Literal
+    LiteralValue = Struct.new(:kind, :value) do
+      def string? = kind == :string || kind == :symbol
+      def as_string = string? ? value : nil
+      def as_bool = (kind == :bool) ? value : nil
+      def as_integer = (kind == :integer) ? value : nil
+      def as_array = (kind == :array) ? value : nil
+      def as_map = (kind == :map) ? value : nil
+    end
+
+    module_function
+
+    def split_top_level(input, separator)
+      output = []
+      start = 0
+      depth = 0
+      quote = nil
+      escaped = false
+
+      input.each_char.with_index do |character, index|
+        if quote
+          if escaped
+            escaped = false
+          elsif character == "\\"
+            escaped = true
+          elsif character == quote
+            quote = nil
+          end
+          next
+        end
+
+        case character
+        when '"', "'"
+          quote = character
+        when "[", "{", "("
+          depth += 1
+        when "]", "}", ")"
+          depth -= 1
+        else
+          if character == separator && depth.zero?
+            segment = input[start...index].strip
+            output << segment unless segment.empty?
+            start = index + 1
+          end
+        end
+      end
+
+      tail = input[start..].strip
+      output << tail unless tail.empty?
+      output
+    end
+
+    def find_top_level(input, token)
+      depth = 0
+      quote = nil
+      escaped = false
+      index = 0
+
+      while index < input.length
+        character = input[index]
+        if quote
+          if escaped
+            escaped = false
+          elsif character == "\\"
+            escaped = true
+          elsif character == quote
+            quote = nil
+          end
+          index += 1
+          next
+        end
+
+        case character
+        when '"', "'"
+          quote = character
+        when "[", "{", "("
+          depth += 1
+        when "]", "}", ")"
+          depth -= 1
+        else
+          return index if depth.zero? && input[index..].start_with?(token)
+        end
+        index += 1
+      end
+      nil
+    end
+
+    def is_balanced?(input)
+      depth = 0
+      quote = nil
+      escaped = false
+
+      input.each_char do |character|
+        if quote
+          if escaped
+            escaped = false
+          elsif character == "\\"
+            escaped = true
+          elsif character == quote
+            quote = nil
+          end
+          next
+        end
+
+        case character
+        when '"', "'"
+          quote = character
+        when "[", "{", "("
+          depth += 1
+        when "]", "}", ")"
+          depth -= 1
+        end
+      end
+
+      depth.zero? && quote.nil?
+    end
+
+    def parse_literal(input)
+      parser = Parser.new(input)
+      value = parser.parse_value
+      parser.skip_whitespace
+      unless parser.finished?
+        raise Error.parse("literal", "unexpected trailing input near #{parser.remaining.inspect}")
+      end
+      value
+    end
+
+    def parse_literal_map(input)
+      value = parse_literal(input)
+      raise Error.parse("literal", "expected map literal, found #{value.inspect}") unless value.kind == :map
+
+      value.value
+    end
+
+    def parse_literal_array(input)
+      value = parse_literal(input)
+      raise Error.parse("literal", "expected array literal, found #{value.inspect}") unless value.kind == :array
+
+      value.value
+    end
+
+    def prepare_parser_lines(text)
+      text.lines.map { |line| prepare_parser_line(line) }
+    end
+
+    def prepare_parser_line(line)
+      strip_line_comment(line).rstrip
+    end
+
+    def strip_line_comment(line)
+      quote = nil
+      escaped = false
+      line.each_char.with_index do |character, index|
+        if quote
+          if escaped
+            escaped = false
+          elsif character == "\\"
+            escaped = true
+          elsif character == quote
+            quote = nil
+          end
+          next
+        end
+
+        case character
+        when '"', "'"
+          quote = character
+        when "#"
+          return line[0...index]
+        end
+      end
+      line
+    end
+
+    class Parser
+      def initialize(input)
+        @input = input
+        @cursor = 0
+      end
+
+      def finished? = @cursor >= @input.length
+      def remaining = @input[@cursor..]
+
+      def skip_whitespace
+        while (character = peek) && character.match?(/\s/)
+          @cursor += 1
+        end
+      end
+
+      def peek = remaining[0]
+
+      def next_character
+        character = peek
+        @cursor += 1 if character
+        character
+      end
+
+      def parse_value
+        skip_whitespace
+        case peek
+        when '"', "'"
+          parse_string
+        when ":"
+          parse_symbol
+        when "["
+          parse_array
+        when "{"
+          parse_map
+        when "-", "0".."9"
+          parse_integer_or_identifier
+        when nil
+          raise Error.parse("literal", "unexpected end of input")
+        else
+          parse_identifier
+        end
+      end
+
+      def parse_string
+        quote = next_character
+        output = +""
+        escaped = false
+        while (character = next_character)
+          if escaped
+            output << case character
+            when "n" then "\n"
+            when "r" then "\r"
+            when "t" then "\t"
+            when "\\" then "\\"
+            when "\"", "'" then character
+            else character
+            end
+            escaped = false
+            next
+          end
+          if character == "\\"
+            escaped = true
+            next
+          end
+          if character == quote
+            return LiteralValue.new(kind: :string, value: output)
+          end
+          output << character
+        end
+        raise Error.parse("literal", "unterminated string literal")
+      end
+
+      def parse_symbol
+        next_character
+        output = +""
+        while (character = peek) && character.match?(%r{[[:alnum:]_\-.\\/]})
+          output << character
+          next_character
+        end
+        raise Error.parse("literal", "empty symbol") if output.empty?
+
+        LiteralValue.new(kind: :symbol, value: output)
+      end
+
+      def parse_array
+        next_character
+        values = []
+        loop do
+          skip_whitespace
+          break if peek == "]" && next_character
+
+          values << parse_value
+          skip_whitespace
+          case peek
+          when ","
+            next_character
+          when "]"
+            next_character
+            break
+          else
+            raise Error.parse("literal", "expected ',' or ']'")
+          end
+        end
+        LiteralValue.new(kind: :array, value: values)
+      end
+
+      def parse_map
+        next_character
+        entries = {}
+        loop do
+          skip_whitespace
+          break if peek == "}" && next_character
+
+          key = parse_map_key
+          skip_whitespace
+          if remaining.start_with?("=>")
+            @cursor += 2
+          elsif peek == ":"
+            next_character
+          else
+            raise Error.parse("literal", "expected ':' or '=>' after map key")
+          end
+          entries[key] = parse_value
+          skip_whitespace
+          case peek
+          when ","
+            next_character
+          when "}"
+            next_character
+            break
+          else
+            raise Error.parse("literal", "expected ',' or '}'")
+          end
+        end
+        LiteralValue.new(kind: :map, value: entries)
+      end
+
+      def parse_map_key
+        skip_whitespace
+        case peek
+        when '"', "'"
+          value = parse_string
+          value.value
+        when ":"
+          parse_symbol.value
+        when "a".."z", "A".."Z", "_"
+          parse_identifier_name
+        else
+          raise Error.parse("literal", "invalid map key")
+        end
+      end
+
+      def parse_integer_or_identifier
+        start = @cursor
+        next_character if peek == "-"
+        while peek&.match?(/[0-9_]/)
+          next_character
+        end
+        if peek == "."
+          return parse_identifier_from(start)
+        end
+        text = @input[start...@cursor].delete("_")
+        LiteralValue.new(kind: :integer, value: Integer(text))
+      rescue ArgumentError => error
+        raise Error.parse("literal", error.message)
+      end
+
+      def parse_identifier
+        identifier = parse_identifier_name
+        case identifier
+        when "true" then LiteralValue.new(kind: :bool, value: true)
+        when "false" then LiteralValue.new(kind: :bool, value: false)
+        when "nil" then LiteralValue.new(kind: :null, value: nil)
+        else LiteralValue.new(kind: :string, value: identifier)
+        end
+      end
+
+      def parse_identifier_name
+        raise Error.parse("literal", "expected identifier") unless identifier_start?(peek)
+
+        start = @cursor
+        next_character
+        while peek && identifier_continue?(peek)
+          next_character
+        end
+        @input[start...@cursor]
+      end
+
+      def parse_identifier_from(start)
+        while peek && (identifier_continue?(peek) || peek == ".")
+          next_character
+        end
+        LiteralValue.new(kind: :string, value: @input[start...@cursor])
+      end
+
+      def identifier_start?(character)
+        character && (character.match?(/[[:alpha:]]/) || character == "_")
+      end
+
+      def identifier_continue?(character)
+        character.match?(%r{[[:alnum:]_\-.\\/]})
+      end
+    end
+  end
+end

data/lib/pray/lockfile.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+require "toml-rb"
+
+require_relative "lockfile_serialize"
+
+module Pray
+  LockSource = Struct.new(:name, :kind, :url, :revision, :host_key_fingerprint)
+  LockedPackage = Struct.new(
+    :name, :version, :source, :path, :tree_hash, :artifact_hash, :artifact,
+    :exports, :dependencies, :signer_fingerprint
+  ) do
+    def initialize(exports: [], dependencies: [], signer_fingerprint: nil, source: nil, **kwargs)
+      super(**kwargs, exports: exports, dependencies: dependencies, signer_fingerprint: signer_fingerprint, source: source)
+    end
+  end
+
+  LockedTarget = Struct.new(:name, :outputs)
+  ManagedSpanRecord = Struct.new(
+    :id, :target, :open_line, :close_line, :ideal_checksum, :package, :export,
+    :source_checksum, :silenced
+  )
+
+  Lockfile = Struct.new(
+    :prayfile_lock, :spec, :generated_by, :manifest_hash, :environment, :source, :package,
+    :target, :managed_span
+  ) do
+    def initialize(
+      prayfile_lock: "1", spec: "0.1", generated_by: Pray::GENERATED_BY,
+      manifest_hash: "", environment: nil, source: [], package: [], target: [], managed_span: []
+    )
+      super
+    end
+
+    def canonicalized
+      dup.tap do |copy|
+        copy.source = source.sort_by(&:name)
+        copy.package = package.sort_by { |entry| [entry.name, entry.source.to_s, entry.version] }
+        copy.target = target.sort_by(&:name)
+        copy.managed_span = managed_span.sort_by { |span| [span.target, span.open_line, span.id] }
+      end
+    end
+
+    def serialized
+      LockfileIO.lockfile_to_toml(canonicalized)
+    end
+
+    def file_hash
+      Hashing.sha256_prefixed(serialized)
+    end
+
+    def equivalent_to?(other)
+      canonicalized == other.canonicalized
+    end
+  end
+
+  module LockfileIO
+    module_function
+
+    def lockfile_to_toml(lockfile)
+      LockfileSerialize.lockfile_to_toml(lockfile)
+    end
+
+    def lockfile_to_hash(lockfile)
+      {
+        "prayfile_lock" => lockfile.prayfile_lock,
+        "spec" => lockfile.spec,
+        "generated_by" => lockfile.generated_by,
+        "manifest_hash" => lockfile.manifest_hash,
+        "source" => lockfile.source.map { |entry| source_to_hash(entry) },
+        "package" => lockfile.package.map { |entry| package_to_hash(entry) },
+        "target" => lockfile.target.map { |entry| {"name" => entry.name, "outputs" => entry.outputs} },
+        "managed_span" => lockfile.managed_span.map { |entry| managed_span_to_hash(entry) }
+      }
+    end
+
+    def source_to_hash(entry)
+      hash = {"name" => entry.name, "kind" => entry.kind, "url" => entry.url}
+      hash["revision"] = entry.revision if entry.revision
+      hash["host_key_fingerprint"] = entry.host_key_fingerprint if entry.host_key_fingerprint
+      hash
+    end
+
+    def package_to_hash(entry)
+      hash = {
+        "name" => entry.name,
+        "version" => entry.version,
+        "path" => entry.path,
+        "tree_hash" => entry.tree_hash,
+        "artifact_hash" => entry.artifact_hash,
+        "artifact" => entry.artifact,
+        "exports" => entry.exports,
+        "dependencies" => entry.dependencies
+      }
+      hash["source"] = entry.source unless entry.source.nil?
+      hash["signer_fingerprint"] = entry.signer_fingerprint if entry.signer_fingerprint
+      hash
+    end
+
+    def managed_span_to_hash(entry)
+      {
+        "id" => entry.id,
+        "target" => entry.target,
+        "open_line" => entry.open_line,
+        "close_line" => entry.close_line,
+        "ideal_checksum" => entry.ideal_checksum,
+        "package" => entry.package,
+        "export" => entry.export,
+        "source_checksum" => entry.source_checksum,
+        "silenced" => entry.silenced
+      }
+    end
+
+    def parse_lockfile(text)
+      data = TomlRB.parse(text)
+      from_hash(data)
+    rescue TomlRB::ParseError => error
+      raise Error.parse("lockfile", error.message)
+    end
+
+    def read_lockfile(path)
+      parse_lockfile(File.read(path))
+    end
+
+    def serialize_lockfile(lockfile)
+      lockfile_to_toml(lockfile.canonicalized)
+    end
+
+    def lockfile_hash(lockfile)
+      Hashing.sha256_prefixed(serialize_lockfile(lockfile))
+    end
+
+    def write_lockfile(path, lockfile)
+      File.write(path, serialize_lockfile(lockfile))
+    end
+
+    def write_lockfile_if_changed(path, lockfile)
+      serialized = serialize_lockfile(lockfile)
+      if File.exist?(path) && File.binread(path) == serialized
+        return
+      end
+
+      File.write(path, serialized)
+    end
+
+    def lockfiles_equivalent?(left, right)
+      left.equivalent_to?(right)
+    end
+
+    def build_lockfile(manifest_hash, environment, project_root, manifest_sources, manifest_targets, rendered, packages, source_revisions, source_host_keys)
+      Lockfile.new(
+        manifest_hash: manifest_hash,
+        environment: environment,
+        source: manifest_sources.map do |source|
+          LockSource.new(
+            name: source.name,
+            kind: source.kind,
+            url: source.url,
+            revision: source_revisions[source.name],
+            host_key_fingerprint: source_host_keys[source.name]
+          )
+        end,
+        package: packages.map do |package|
+          LockedPackage.new(
+            name: package.declaration.name,
+            version: package.spec.version,
+            source: package.declaration.source,
+            path: relative_lockfile_path(project_root, package.root),
+            tree_hash: package.tree_hash,
+            artifact_hash: package.artifact_hash,
+            artifact: normalize_lockfile_artifact(project_root, package.artifact, package.root),
+            exports: package.selected_exports,
+            dependencies: package.spec.dependencies.map(&:name),
+            signer_fingerprint: package.signer_fingerprint
+          )
+        end,
+        target: manifest_targets.map { |target| LockedTarget.new(name: target.name, outputs: target.outputs) },
+        managed_span: rendered.flat_map(&:managed_spans)
+      ).canonicalized
+    end
+
+    def from_hash(data)
+      Lockfile.new(
+        prayfile_lock: data["prayfile_lock"],
+        spec: data["spec"],
+        generated_by: data["generated_by"],
+        manifest_hash: data["manifest_hash"],
+        environment: data["environment"],
+        source: Array(data["source"]).map do |entry|
+          LockSource.new(
+            name: entry["name"],
+            kind: entry["kind"],
+            url: entry["url"],
+            revision: entry["revision"],
+            host_key_fingerprint: entry["host_key_fingerprint"]
+          )
+        end,
+        package: Array(data["package"]).map do |entry|
+          LockedPackage.new(
+            name: entry["name"],
+            version: entry["version"],
+            source: entry["source"],
+            path: entry["path"],
+            tree_hash: entry["tree_hash"],
+            artifact_hash: entry["artifact_hash"],
+            artifact: entry["artifact"],
+            exports: entry["exports"] || [],
+            dependencies: entry["dependencies"] || [],
+            signer_fingerprint: entry["signer_fingerprint"]
+          )
+        end,
+        target: Array(data["target"]).map { |entry| LockedTarget.new(name: entry["name"], outputs: entry["outputs"] || []) },
+        managed_span: Array(data["managed_span"]).map do |entry|
+          ManagedSpanRecord.new(
+            id: entry["id"],
+            target: entry["target"],
+            open_line: entry["open_line"],
+            close_line: entry["close_line"],
+            ideal_checksum: entry["ideal_checksum"],
+            package: entry["package"],
+            export: entry["export"],
+            source_checksum: entry["source_checksum"],
+            silenced: entry["silenced"]
+          )
+        end
+      )
+    end
+
+    def relative_lockfile_path(project_root, path)
+      absolute = Pathname(path).absolute? ? Pathname(path) : Pathname(project_root).join(path)
+      normalized_root = Pathname(project_root).cleanpath
+      normalized_absolute = absolute.cleanpath
+      relative = normalized_absolute.relative_path_from(normalized_root)
+      format_relative_lockfile_path(relative)
+    rescue ArgumentError
+      format_relative_lockfile_path(Pathname(path).cleanpath)
+    end
+
+    def format_relative_lockfile_path(relative)
+      text = relative.to_s.tr("\\", "/")
+      (text == "." || text.start_with?("./")) ? text : "./#{text}"
+    end
+
+    def normalize_lockfile_artifact(project_root, artifact, package_root)
+      return artifact unless artifact.start_with?("path:")
+
+      path_text = artifact.delete_prefix("path:")
+      path = Pathname(path_text)
+      relative = if path.absolute?
+        relative_lockfile_path(project_root, path)
+      else
+        relative_lockfile_path(project_root, package_root)
+      end
+      "path:#{relative}"
+    end
+  end
+
+  extend LockfileIO
+end