ast-merge-git 7.1.7 → 7.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2943a67a2400053c0f535008977a3aad094685b0fd2c21423694a7e611176a2b
-  data.tar.gz: a734402394056e68c03fab8a40e23b3a6be091e98f77275921202d15e1915c37
+  metadata.gz: d73aa6351e792720651576508f7e9e85c3052648de6ba18fdd6889398f60d804
+  data.tar.gz: 01d368cc15f274ceabbd49805d52f05db59011304d68756e6176b4b3a6b2d465
 SHA512:
-  metadata.gz: 13a17a48ce7ffed824dd30841e4a1f8f236aa8237b3ca38020db745ac4c12ffbe47ebdbc69ff290725776cafd71d2fa1b2c67c251b87749a7f36a9d06393b060
-  data.tar.gz: a70e57f231ac0fc014aa0b6e49eccfc14a0cab8aefbd8a3ae9d781da8a72253fa6af584c26edb13d6208e01d8162cc67e8c4413610698a9050edf60ab8fc5014
+  metadata.gz: e66bd81ebaff38eb315d2b5d8164d00d48baadb3bf92ce055e60ca8d2b7845b3627a07176886681c3e4f1dca5c473ae782c29efb00af42637dd9e8624cd61a2f
+  data.tar.gz: e5c259116fce46cad58a446548d01761b04ee83b8c73f97954d56256cfb87196a4127a423a46885dd9053e3b83b56837b73dd530122176f5da8a96f4a356c96b

data/exe/ast-merge-git

@@ -3,6 +3,11 @@
 
 require 'ast/merge/git'
 
+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'
 
@@ -52,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
@@ -83,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