the_mechanic_2 0.1.0

data/app/controllers/the_mechanic_2/benchmarks_controller.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module TheMechanic2
+  # Main controller for benchmark operations
+  # Handles UI rendering and API endpoints
+  class BenchmarksController < ApplicationController
+    before_action :check_authentication, if: -> { TheMechanic2.configuration.enable_authentication }
+    
+    # GET /ask_the_mechanic
+    # Renders the main benchmarking UI
+    def index
+      render template: 'the_mechanic_2/benchmarks/index'
+    end
+    
+    # POST /ask_the_mechanic_2/validate
+    # Validates code without executing
+    def validate
+      code_a = params[:code_a]
+      code_b = params[:code_b]
+      
+      errors = []
+      
+      # Validate code_a
+      if code_a.present?
+        validation_a = SecurityService.validate(code_a)
+        errors.concat(validation_a[:errors].map { |e| "Code A: #{e}" }) unless validation_a[:valid]
+      else
+        errors << 'Code A: Code is required'
+      end
+      
+      # Validate code_b
+      if code_b.present?
+        validation_b = SecurityService.validate(code_b)
+        errors.concat(validation_b[:errors].map { |e| "Code B: #{e}" }) unless validation_b[:valid]
+      else
+        errors << 'Code B: Code is required'
+      end
+      
+      # Validate shared_setup if provided
+      if params[:shared_setup].present?
+        validation_setup = SecurityService.validate(params[:shared_setup])
+        errors.concat(validation_setup[:errors].map { |e| "Shared Setup: #{e}" }) unless validation_setup[:valid]
+      end
+      
+      if errors.empty?
+        render json: { valid: true, message: 'All code is valid' }
+      else
+        render json: { valid: false, errors: errors }, status: :unprocessable_entity
+      end
+    end
+    
+    # POST /ask_the_mechanic_2/run
+    # Executes benchmark comparison
+    def run
+      # Validate request
+      request = BenchmarkRequest.new(
+        shared_setup: params[:shared_setup],
+        code_a: params[:code_a],
+        code_b: params[:code_b],
+        timeout: params[:timeout]&.to_i
+      )
+      
+      unless request.valid?
+        render json: { error: 'Invalid request', errors: request.all_errors }, status: :unprocessable_entity
+        return
+      end
+      
+      # Validate code security
+      validation_result = validate_code_security(request)
+      unless validation_result[:valid]
+        render json: { error: 'Security validation failed', errors: validation_result[:errors] }, status: :unprocessable_entity
+        return
+      end
+      
+      # Execute benchmark
+      begin
+        service = BenchmarkService.new
+        results = service.run(
+          shared_setup: request.shared_setup,
+          code_a: request.code_a,
+          code_b: request.code_b,
+          timeout: request.timeout
+        )
+        
+        render json: results
+      rescue RailsRunnerService::BenchmarkTimeout => e
+        render json: { error: 'Benchmark timeout', message: e.message }, status: :request_timeout
+      rescue RailsRunnerService::BenchmarkError => e
+        render json: { error: 'Benchmark execution failed', message: e.message }, status: :internal_server_error
+      rescue StandardError => e
+        render json: { error: 'Unexpected error', message: e.message }, status: :internal_server_error
+      end
+    end
+    
+    # POST /ask_the_mechanic_2/export
+    # Exports results in specified format
+    def export
+      results_data = params[:results]
+      format = params[:format] || 'json'
+      
+      unless results_data
+        render json: { error: 'Results data is required' }, status: :unprocessable_entity
+        return
+      end
+      
+      begin
+        result = BenchmarkResult.new(results_data.permit!.to_h.symbolize_keys)
+        
+        case format
+        when 'json'
+          render json: result.to_json, content_type: 'application/json'
+        when 'markdown'
+          render plain: result.to_markdown, content_type: 'text/markdown'
+        else
+          render json: { error: 'Invalid format. Use json or markdown' }, status: :unprocessable_entity
+        end
+      rescue StandardError => e
+        render json: { error: 'Export failed', message: e.message }, status: :internal_server_error
+      end
+    end
+    
+    private
+    
+    # Checks authentication using configured callback
+    def check_authentication
+      callback = TheMechanic2.configuration.authentication_callback
+      return unless callback
+      
+      unless callback.call(self)
+        render json: { error: 'Unauthorized' }, status: :unauthorized
+      end
+    end
+    
+    # Validates code security for all code snippets
+    def validate_code_security(request)
+      errors = []
+      
+      # Validate shared_setup if present
+      if request.shared_setup.present?
+        validation = SecurityService.validate(request.shared_setup)
+        errors.concat(validation[:errors].map { |e| "Shared Setup: #{e}" }) unless validation[:valid]
+      end
+      
+      # Validate code_a
+      validation_a = SecurityService.validate(request.code_a)
+      errors.concat(validation_a[:errors].map { |e| "Code A: #{e}" }) unless validation_a[:valid]
+      
+      # Validate code_b
+      validation_b = SecurityService.validate(request.code_b)
+      errors.concat(validation_b[:errors].map { |e| "Code B: #{e}" }) unless validation_b[:valid]
+      
+      { valid: errors.empty?, errors: errors }
+    end
+    
+    # Helper methods for asset inlining (to be implemented later)
+    helper_method :inline_css, :inline_javascript
+    
+    def inline_css
+      @inline_css ||= read_asset_file('stylesheets/the_mechanic_2/application.css')
+    end
+    
+    def inline_javascript
+      @inline_javascript ||= read_asset_file('javascripts/the_mechanic_2/application.js')
+    end
+    
+    def read_asset_file(path)
+      file_path = TheMechanic2::Engine.root.join('app', 'assets', path)
+      File.exist?(file_path) ? File.read(file_path) : ''
+    rescue StandardError => e
+      Rails.logger.error("Failed to read asset file #{path}: #{e.message}")
+      ''
+    end
+  end
+end

data/app/helpers/the_mechanic_2/application_helper.rb

@@ -0,0 +1,4 @@
+module TheMechanic2
+  module ApplicationHelper
+  end
+end

data/app/jobs/the_mechanic_2/application_job.rb

@@ -0,0 +1,4 @@
+module TheMechanic2
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/the_mechanic_2/application_mailer.rb

@@ -0,0 +1,6 @@
+module TheMechanic2
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/models/the_mechanic_2/application_record.rb

@@ -0,0 +1,5 @@
+module TheMechanic2
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/the_mechanic_2/benchmark_request.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module TheMechanic2
+  # Model for validating benchmark request parameters
+  # Ensures all required fields are present and valid
+  class BenchmarkRequest
+    attr_reader :shared_setup, :code_a, :code_b, :timeout, :errors
+    
+    # Minimum and maximum allowed timeout values
+    MIN_TIMEOUT = 1
+    MAX_TIMEOUT = 300
+    
+    def initialize(params = {})
+      @shared_setup = params[:shared_setup]
+      @code_a = params[:code_a]
+      @code_b = params[:code_b]
+      @timeout = params[:timeout] || TheMechanic2.configuration.timeout
+      @errors = []
+    end
+    
+    # Validates the request parameters
+    # @return [Boolean] true if valid, false otherwise
+    def valid?
+      @errors = []
+      
+      validate_code_a
+      validate_code_b
+      validate_timeout
+      
+      @errors.empty?
+    end
+    
+    # Returns validation errors as a hash
+    # @return [Hash] errors grouped by field
+    def error_messages
+      {
+        code_a: @errors.select { |e| e.include?('Code A') },
+        code_b: @errors.select { |e| e.include?('Code B') },
+        timeout: @errors.select { |e| e.include?('Timeout') },
+        general: @errors.reject { |e| e.include?('Code A') || e.include?('Code B') || e.include?('Timeout') }
+      }
+    end
+    
+    # Returns all errors as a flat array
+    # @return [Array<String>] all error messages
+    def all_errors
+      @errors
+    end
+    
+    private
+    
+    def validate_code_a
+      if @code_a.nil? || @code_a.strip.empty?
+        @errors << 'Code A is required and cannot be empty'
+      end
+    end
+    
+    def validate_code_b
+      if @code_b.nil? || @code_b.strip.empty?
+        @errors << 'Code B is required and cannot be empty'
+      end
+    end
+    
+    def validate_timeout
+      unless @timeout.is_a?(Numeric)
+        @errors << 'Timeout must be a number'
+        return
+      end
+      
+      if @timeout < MIN_TIMEOUT
+        @errors << "Timeout must be at least #{MIN_TIMEOUT} second(s)"
+      end
+      
+      if @timeout > MAX_TIMEOUT
+        @errors << "Timeout cannot exceed #{MAX_TIMEOUT} seconds"
+      end
+    end
+  end
+end

data/app/models/the_mechanic_2/benchmark_result.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module TheMechanic2
+  # Model for formatting and exporting benchmark results
+  # Provides JSON and Markdown export capabilities
+  class BenchmarkResult
+    attr_reader :code_a_metrics, :code_b_metrics, :winner, :performance_ratio, :summary
+    
+    def initialize(data)
+      @code_a_metrics = data[:code_a_metrics]
+      @code_b_metrics = data[:code_b_metrics]
+      @winner = data[:winner]
+      @performance_ratio = data[:performance_ratio]
+      @summary = data[:summary]
+    end
+    
+    # Exports results as JSON
+    # @return [String] JSON representation of results
+    def to_json(*_args)
+      {
+        code_a_metrics: @code_a_metrics,
+        code_b_metrics: @code_b_metrics,
+        winner: @winner,
+        performance_ratio: @performance_ratio,
+        summary: @summary,
+        timestamp: Time.now.iso8601
+      }.to_json
+    end
+    
+    # Exports results as Markdown
+    # @return [String] Markdown formatted results
+    def to_markdown
+      <<~MARKDOWN
+        # Ruby Benchmark Results
+        
+        **Winner:** #{winner_text}
+        
+        **Summary:** #{@summary}
+        
+        ## Performance Metrics
+        
+        | Metric | Code A | Code B |
+        |--------|--------|--------|
+        | IPS (iterations/sec) | #{format_number(@code_a_metrics[:ips])} | #{format_number(@code_b_metrics[:ips])} |
+        | Standard Deviation | #{format_number(@code_a_metrics[:stddev])} | #{format_number(@code_b_metrics[:stddev])} |
+        | Objects Allocated | #{format_number(@code_a_metrics[:objects])} | #{format_number(@code_b_metrics[:objects])} |
+        | Memory (MB) | #{format_number(@code_a_metrics[:memory_mb])} | #{format_number(@code_b_metrics[:memory_mb])} |
+        | Execution Time (sec) | #{format_number(@code_a_metrics[:execution_time])} | #{format_number(@code_b_metrics[:execution_time])} |
+        
+        ## Analysis
+        
+        #{analysis_text}
+        
+        ---
+        
+        *Generated at #{Time.now.strftime('%Y-%m-%d %H:%M:%S')}*
+      MARKDOWN
+    end
+    
+    # Returns a hash representation of the results
+    # @return [Hash] results as a hash
+    def to_h
+      {
+        code_a_metrics: @code_a_metrics,
+        code_b_metrics: @code_b_metrics,
+        winner: @winner,
+        performance_ratio: @performance_ratio,
+        summary: @summary
+      }
+    end
+    
+    private
+    
+    def winner_text
+      case @winner
+      when 'code_a'
+        "Code A (#{@performance_ratio}× faster)"
+      when 'code_b'
+        "Code B (#{@performance_ratio}× faster)"
+      when 'tie'
+        'Tie (similar performance)'
+      else
+        'Unknown'
+      end
+    end
+    
+    def analysis_text
+      lines = []
+      
+      # Performance analysis
+      if @winner == 'tie'
+        lines << "Both code snippets have similar performance characteristics."
+      else
+        faster = @winner == 'code_a' ? 'Code A' : 'Code B'
+        slower = @winner == 'code_a' ? 'Code B' : 'Code A'
+        lines << "#{faster} is significantly faster than #{slower} by a factor of #{@performance_ratio}×."
+      end
+      
+      # Memory analysis
+      memory_diff = (@code_a_metrics[:memory_mb] - @code_b_metrics[:memory_mb]).abs
+      if memory_diff > 0.01 # More than 0.01 MB difference
+        less_memory = @code_a_metrics[:memory_mb] < @code_b_metrics[:memory_mb] ? 'Code A' : 'Code B'
+        lines << "#{less_memory} uses less memory."
+      else
+        lines << "Both snippets have similar memory usage."
+      end
+      
+      # Object allocation analysis
+      obj_diff = (@code_a_metrics[:objects] - @code_b_metrics[:objects]).abs
+      if obj_diff > 10 # More than 10 objects difference
+        fewer_objects = @code_a_metrics[:objects] < @code_b_metrics[:objects] ? 'Code A' : 'Code B'
+        lines << "#{fewer_objects} allocates fewer objects."
+      end
+      
+      lines.join("\n\n")
+    end
+    
+    def format_number(num)
+      return '0' if num.nil?
+      
+      if num.is_a?(Float)
+        if num < 0.01
+          format('%.6f', num)
+        elsif num < 1
+          format('%.4f', num)
+        elsif num < 100
+          format('%.2f', num)
+        else
+          num.round.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
+        end
+      else
+        num.to_s.reverse.gsub(/(\d{3})(?=\d)/, '\\1,').reverse
+      end
+    end
+  end
+end

data/app/services/the_mechanic_2/benchmark_service.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module TheMechanic2
+  # Service for orchestrating benchmark execution
+  # Coordinates between RailsRunnerService and result formatting
+  class BenchmarkService
+    # Executes a benchmark comparison between two code snippets
+    # @param shared_setup [String] Optional setup code to run before both snippets
+    # @param code_a [String] First code snippet to benchmark
+    # @param code_b [String] Second code snippet to benchmark
+    # @param timeout [Integer] Maximum execution time per benchmark in seconds
+    # @return [Hash] Formatted benchmark results with winner and metrics
+    def run(shared_setup:, code_a:, code_b:, timeout: 30)
+      runner = RailsRunnerService.new
+      
+      # Execute code_a
+      result_a = runner.execute(
+        code: code_a,
+        shared_setup: shared_setup,
+        timeout: timeout
+      )
+      
+      # Execute code_b
+      result_b = runner.execute(
+        code: code_b,
+        shared_setup: shared_setup,
+        timeout: timeout
+      )
+      
+      # Format and return results
+      format_results(result_a, result_b)
+    end
+    
+    private
+    
+    # Formats the benchmark results and determines the winner
+    # @param result_a [Hash] Results from code_a
+    # @param result_b [Hash] Results from code_b
+    # @return [Hash] Formatted results with winner and comparison
+    def format_results(result_a, result_b)
+      # Determine winner based on IPS (higher is better)
+      winner = determine_winner(result_a[:ips], result_b[:ips])
+      
+      # Calculate performance ratio
+      ratio = calculate_ratio(result_a[:ips], result_b[:ips], winner)
+      
+      {
+        code_a_metrics: {
+          ips: result_a[:ips],
+          stddev: result_a[:stddev],
+          objects: result_a[:objects],
+          memory_mb: result_a[:memory_mb],
+          execution_time: result_a[:execution_time]
+        },
+        code_b_metrics: {
+          ips: result_b[:ips],
+          stddev: result_b[:stddev],
+          objects: result_b[:objects],
+          memory_mb: result_b[:memory_mb],
+          execution_time: result_b[:execution_time]
+        },
+        winner: winner,
+        performance_ratio: ratio,
+        summary: generate_summary(winner, ratio)
+      }
+    end
+    
+    # Determines which code snippet is the winner
+    # @param ips_a [Float] Iterations per second for code A
+    # @param ips_b [Float] Iterations per second for code B
+    # @return [String] 'code_a', 'code_b', or 'tie'
+    def determine_winner(ips_a, ips_b)
+      # Consider it a tie if difference is less than 5%
+      diff_percentage = ((ips_a - ips_b).abs / [ips_a, ips_b].max) * 100
+      
+      if diff_percentage < 5
+        'tie'
+      elsif ips_a > ips_b
+        'code_a'
+      else
+        'code_b'
+      end
+    end
+    
+    # Calculates the performance ratio between the two code snippets
+    # @param ips_a [Float] Iterations per second for code A
+    # @param ips_b [Float] Iterations per second for code B
+    # @param winner [String] The winner ('code_a', 'code_b', or 'tie')
+    # @return [Float] Performance ratio (how much faster the winner is)
+    def calculate_ratio(ips_a, ips_b, winner)
+      return 1.0 if winner == 'tie'
+      
+      if winner == 'code_a'
+        (ips_a / ips_b).round(2)
+      else
+        (ips_b / ips_a).round(2)
+      end
+    end
+    
+    # Generates a human-readable summary of the results
+    # @param winner [String] The winner
+    # @param ratio [Float] Performance ratio
+    # @return [String] Summary text
+    def generate_summary(winner, ratio)
+      case winner
+      when 'tie'
+        'Both code snippets have similar performance (within 5% difference)'
+      when 'code_a'
+        "Code A is #{ratio}× faster than Code B"
+      when 'code_b'
+        "Code B is #{ratio}× faster than Code A"
+      end
+    end
+  end
+end