ast-merge-git 7.1.6 → 7.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f77299ac80ed9c1b08218ab290de6784428c7fc691e1693df0f6a074b33a6cd
-  data.tar.gz: 4b43c57ae0f44ce041cc3db5ae098e0f517666a634f791414d3860893caa404b
+  metadata.gz: d73aa6351e792720651576508f7e9e85c3052648de6ba18fdd6889398f60d804
+  data.tar.gz: 01d368cc15f274ceabbd49805d52f05db59011304d68756e6176b4b3a6b2d465
 SHA512:
-  metadata.gz: 81a80302f650d7f80415a5fa34a2b0e3ceb3bcab3169a8eb15000b592e994e71a9ae9377e47b033e6f3fa50ddde34c8585aa2ba756ccefaf24cd4950ba7de484
-  data.tar.gz: 7608307153363924e423f9ed7f0021407094e5520c2b919c6e40c4f676f54168c4cb6e4658059b978fc1bb255e944cec52fb66238c18bc834110f14a6c3cf838
+  metadata.gz: e66bd81ebaff38eb315d2b5d8164d00d48baadb3bf92ce055e60ca8d2b7845b3627a07176886681c3e4f1dca5c473ae782c29efb00af42637dd9e8624cd61a2f
+  data.tar.gz: e5c259116fce46cad58a446548d01761b04ee83b8c73f97954d56256cfb87196a4127a423a46885dd9053e3b83b56837b73dd530122176f5da8a96f4a356c96b

data/exe/ast-merge-git

@@ -3,31 +3,47 @@
 
 require 'ast/merge/git'
 
-if ARGV.first == 'benchmark-provider-diff'
+if ARGV.first == 'benchmark-provider-session'
+  Ast::Merge::Git::BenchmarkAdapter.serve
+  exit 0
+end
+
+if %w[benchmark-provider-diff benchmark-provider-merge2].include?(ARGV.first)
   require 'json'
 
   begin
-    before_path, after_path, path_name = ARGV.drop(1)
-    raise ArgumentError, 'before, after, and path name are required' unless before_path && after_path && path_name
+    command = ARGV.first
+    first_path, second_path, path_name = ARGV.drop(1)
+    raise ArgumentError, 'two source paths and path name are required' unless first_path && second_path && path_name
 
+    operation, role_sources = if command == 'benchmark-provider-diff'
+                                [:diff2, {
+                                  before_source: File.binread(first_path),
+                                  after_source: File.binread(second_path)
+                                }]
+                              else
+                                [:merge2, {
+                                  incoming_source: File.binread(first_path),
+                                  current_source: File.binread(second_path)
+                                }]
+                              end
     require ENV.fetch('AST_MERGE_REQUIRE')
     result = Ast::Merge.dispatch_provider(
-      :diff2,
+      operation,
       {
         provider_id: ENV.fetch('AST_MERGE_PROVIDER'),
         family: ENV.fetch('AST_MERGE_FAMILY'),
         dialect: ENV.fetch('AST_MERGE_DIALECT'),
         backend: ENV.fetch('AST_MERGE_BACKEND'),
         profile_id: ENV.fetch('AST_MERGE_PROFILE'),
-        before_source: File.binread(before_path),
-        after_source: File.binread(after_path),
-        path_name: path_name
+        path_name: path_name,
+        **role_sources
       }
     )
     puts JSON.generate(Ast::Merge.json_ready(result))
     exit(result[:ok] == true ? 0 : 2)
   rescue ArgumentError, Ast::Merge::Error, KeyError, LoadError, SystemCallError => e
-    warn "ast-merge-git benchmark-provider-diff: #{e.message}"
+    warn "ast-merge-git #{ARGV.first}: #{e.message}"
     exit 2
   end
 end
@@ -41,17 +57,23 @@ if ARGV.first == 'benchmark'
     profile: 'micro',
     changed_paths: [],
     tmp_root: File.expand_path('../tmp/benchmark', __dir__),
-    timeout: 30
+    timeout: 30,
+    iterations: 1,
+    workers: 1
   }
   parser = OptionParser.new do |opts|
-    opts.banner = 'usage: ast-merge-git benchmark validate|select|run|report [options]'
+    opts.banner = 'usage: ast-merge-git benchmark validate|select|run|report|performance [options]'
     opts.on('--corpus PATH') { |value| options[:corpus] = value }
     opts.on('--profile PROFILE') { |value| options[:profile] = value }
     opts.on('--changed-path PATH') { |value| options[:changed_paths] << value }
     opts.on('--driver PATH') { |value| options[:driver] = value }
+    opts.on('--adapter-descriptor PATH') { |value| options[:adapter_descriptor] = value }
+    opts.on('--git PATH') { |value| options[:git] = value }
     opts.on('--mergiraf PATH') { |value| options[:mergiraf] = value }
     opts.on('--tmp-root PATH') { |value| options[:tmp_root] = value }
     opts.on('--timeout SECONDS', Integer) { |value| options[:timeout] = value }
+    opts.on('--iterations COUNT', Integer) { |value| options[:iterations] = value }
+    opts.on('--workers COUNT', Integer) { |value| options[:workers] = value }
   end
 
   begin
@@ -72,9 +94,27 @@ if ARGV.first == 'benchmark'
                  driver_path: driver,
                  tmp_root: options[:tmp_root],
                  timeout: options[:timeout],
-                 competitor_paths: options[:mergiraf] ? { 'mergiraf' => options[:mergiraf] } : {}
+                 competitor_paths: {
+                   'git' => options[:git],
+                   'mergiraf' => options[:mergiraf]
+                 }.compact,
+                 workers: options[:workers],
+                 adapter_descriptor: options[:adapter_descriptor]
                ).run(profile: options[:profile], changed_paths: options[:changed_paths])
                command == 'report' ? Ast::Merge::Git::LocalBenchmarkReport.build(run) : run
+             when 'performance'
+               driver = options[:driver] || Gem.bin_path('ast-merge-git', 'ast-merge-git')
+               Ast::Merge::Git::LocalBenchmarkRunner.new(
+                 benchmark: benchmark,
+                 driver_path: driver,
+                 tmp_root: options[:tmp_root],
+                 timeout: options[:timeout],
+                 adapter_descriptor: options[:adapter_descriptor]
+               ).performance(
+                 profile: options[:profile],
+                 changed_paths: options[:changed_paths],
+                 iterations: options[:iterations]
+               )
              else
                warn parser
                exit 2

data/lib/ast/merge/git/benchmark_adapter.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Ast
+  module Merge
+    module Git
+      # Versioned JSONL protocol for repeated benchmark operations in one Ruby process.
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/ModuleLength, Metrics/PerceivedComplexity -- protocol validation and dispatch remain explicit
+      module BenchmarkAdapter
+        REQUEST_SCHEMA = 'structuredmerge.benchmark.adapter-request/v1'
+        RESPONSE_SCHEMA = 'structuredmerge.benchmark.adapter-response/v1'
+        OPERATIONS = %w[diff2 merge2 merge3].freeze
+        SOURCE_ROLES = {
+          'diff2' => %w[before after],
+          'merge2' => %w[incoming current],
+          'merge3' => %w[base ours theirs]
+        }.freeze
+
+        module_function
+
+        def serve(input: $stdin, output: $stdout)
+          input.each_line do |line|
+            next if line.strip.empty?
+
+            response = execute(JSON.parse(line))
+            output.puts(JSON.generate(response))
+            output.flush
+          rescue JSON::ParserError => e
+            output.puts(JSON.generate(error_response(nil, e)))
+            output.flush
+          end
+        end
+
+        def execute(request)
+          started = monotonic_nanoseconds
+          operation, selector, sources = validate_request(request)
+          require selector.fetch('require')
+          result = dispatch(operation, selector, sources, request.fetch('path_name'))
+
+          response_for(request.fetch('request_id'), operation, result, monotonic_nanoseconds - started)
+        rescue ArgumentError, Ast::Merge::Error, KeyError, LoadError => e
+          error_response(request.is_a?(Hash) ? request['request_id'] : nil, e, started: started)
+        end
+
+        def validate_request(request)
+          raise ArgumentError, 'request must be an object' unless request.is_a?(Hash)
+          raise ArgumentError, 'unsupported request schema' unless request['schema_version'] == REQUEST_SCHEMA
+
+          operation = request.fetch('operation')
+          raise ArgumentError, "unsupported operation: #{operation.inspect}" unless OPERATIONS.include?(operation)
+
+          selector = request.fetch('selector')
+          raise ArgumentError, 'selector must be an object' unless selector.is_a?(Hash)
+
+          %w[provider_id family dialect backend profile require].each { |key| selector.fetch(key) }
+          encoded_sources = request.fetch('sources')
+          raise ArgumentError, 'sources must be an object' unless encoded_sources.is_a?(Hash)
+
+          sources = SOURCE_ROLES.fetch(operation).to_h do |role|
+            [role, decode_source(encoded_sources.fetch(role))]
+          end
+          [operation, selector, sources]
+        rescue ArgumentError => e
+          raise ArgumentError, "invalid base64 source: #{e.message}" if e.message.include?('invalid base64')
+
+          raise
+        end
+        private_class_method :validate_request
+
+        def dispatch(operation, selector, sources, path_name)
+          request = {
+            provider_id: selector.fetch('provider_id'),
+            family: selector.fetch('family'),
+            dialect: selector.fetch('dialect'),
+            backend: selector.fetch('backend'),
+            profile_id: selector.fetch('profile'),
+            path_name: path_name
+          }
+
+          case operation
+          when 'diff2'
+            Ast::Merge.dispatch_provider(
+              :diff2,
+              request.merge(before_source: sources.fetch('before'), after_source: sources.fetch('after'))
+            )
+          when 'merge2'
+            Ast::Merge.dispatch_provider(
+              :merge2,
+              request.merge(incoming_source: sources.fetch('incoming'), current_source: sources.fetch('current'))
+            )
+          when 'merge3'
+            Ast::Merge::Git.merge3(
+              request.merge(
+                base_source: sources.fetch('base'),
+                ours_source: sources.fetch('ours'),
+                theirs_source: sources.fetch('theirs')
+              )
+            )
+          end
+        end
+        private_class_method :dispatch
+
+        def response_for(request_id, operation, result, duration_ns)
+          output = operation_output(operation, result)
+          {
+            'schema_version' => RESPONSE_SCHEMA,
+            'request_id' => request_id,
+            'process_id' => Process.pid,
+            'operation' => operation,
+            'status' => operation_status(operation, result),
+            'duration_ns' => duration_ns,
+            'output_base64' => encode_source(output),
+            'result' => Ast::Merge.json_ready(
+              result.slice(:ok, :changes, :conflicts, :diagnostics, :verification)
+            ),
+            'stderr' => ''
+          }
+        end
+        private_class_method :response_for
+
+        def operation_output(operation, result)
+          case operation
+          when 'diff2'
+            JSON.generate(Ast::Merge.json_ready(result.fetch(:changes, [])))
+          when 'merge2'
+            result[:ok] ? result.fetch(:output) : ''
+          when 'merge3'
+            result[:ok] ? result.fetch(:merged_source) : result.fetch(:conflicted_source, '').to_s
+          end
+        end
+        private_class_method :operation_output
+
+        def operation_status(operation, result)
+          return 0 if result[:ok]
+          return 1 if operation == 'merge3' && result.fetch(:conflicts, []).any?
+
+          2
+        end
+        private_class_method :operation_status
+
+        def encode_source(source)
+          [source.b].pack('m0')
+        end
+
+        def decode_source(encoded)
+          encoded.unpack1('m0')
+        end
+
+        def error_response(request_id, error, started: nil)
+          {
+            'schema_version' => RESPONSE_SCHEMA,
+            'request_id' => request_id,
+            'process_id' => Process.pid,
+            'status' => 2,
+            'duration_ns' => started ? monotonic_nanoseconds - started : 0,
+            'output_base64' => '',
+            'result' => {},
+            'stderr' => error.message
+          }
+        end
+        private_class_method :error_response
+
+        def monotonic_nanoseconds
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, :nanosecond)
+        end
+        private_class_method :monotonic_nanoseconds
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/ModuleLength, Metrics/PerceivedComplexity
+    end
+  end
+end