regresso 0.1.0

data/lib/generators/regresso/install_generator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module Regresso
+  # Rails generators for Regresso setup.
+  module Generators
+    # Installs Regresso initializer and snapshot directories.
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      # Creates config/initializers/regresso.rb.
+      def create_initializer
+        copy_file "regresso.rb", "config/initializers/regresso.rb"
+      end
+
+      # Creates the snapshot directory with a .gitkeep file.
+      def create_snapshot_directory
+        empty_directory "spec/snapshots/regresso"
+        create_file "spec/snapshots/regresso/.gitkeep"
+      end
+
+      # Adds Regresso snapshot temp files to .gitignore.
+      def add_to_gitignore
+        append_to_file ".gitignore", "\n# Regresso temporary files\nspec/snapshots/regresso/*.tmp\n"
+      end
+    end
+  end
+end

data/lib/generators/regresso/templates/regresso.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+Regresso.configure do |config|
+  # Default numeric tolerance for comparisons
+  config.default_tolerance = 0.0
+
+  # Paths to ignore (String or Regexp)
+  config.ignore_paths = []
+
+  # Per-path tolerance overrides
+  config.tolerance_overrides = {}
+
+  # Array order sensitivity
+  config.array_order_sensitive = true
+
+  # Type coercion for numeric comparison
+  config.type_coercion = true
+end

data/lib/regresso/adapters/base.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Regresso
+  # Data source adapters for comparison inputs.
+  module Adapters
+    # Base interface for adapters.
+    class Base
+      attr_reader :options
+
+      # @param options [Hash]
+      def initialize(**options)
+        @options = options
+      end
+
+      # Fetches data from the source.
+      #
+      # @return [Object]
+      def fetch
+        raise NotImplementedError, "Adapters must implement #fetch"
+      end
+
+      # Returns a short description of the source.
+      #
+      # @return [String]
+      def description
+        raise NotImplementedError, "Adapters must implement #description"
+      end
+    end
+  end
+end

data/lib/regresso/adapters/csv.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "csv"
+
+module Regresso
+  module Adapters
+    # Adapter that parses CSV input into a comparable structure.
+    class Csv < Base
+      # @param path [String,nil]
+      # @param content [String,nil]
+      # @param headers [Boolean]
+      # @param col_sep [String]
+      def initialize(path: nil, content: nil, headers: true, col_sep: ",")
+        super()
+        @path = path
+        @content = content
+        @headers = headers
+        @col_sep = col_sep
+      end
+
+      # Parses CSV into an array of hashes.
+      #
+      # @return [Array<Hash>]
+      def fetch
+        csv_content = @content || File.read(@path)
+        rows = CSV.parse(csv_content, headers: @headers, col_sep: @col_sep)
+        if @headers
+          rows.map(&:to_h)
+        else
+          rows.map do |row|
+            values = row.is_a?(CSV::Row) ? row.fields : row
+            values.each_with_index.to_h { |value, index| [index.to_s, value] }
+          end
+        end
+      end
+
+      # @return [String]
+      def description
+        @path ? "CSV: #{@path}" : "CSV (inline content)"
+      end
+    end
+  end
+end

data/lib/regresso/adapters/database.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module Regresso
+  module Adapters
+    # Adapter that runs a query against a database connection.
+    class Database < Base
+      # @param connection_config [Hash]
+      # @param query [String]
+      # @param params [Hash]
+      # @param row_identifier [String,Symbol,nil]
+      def initialize(connection_config:, query:, params: {}, row_identifier: nil)
+        super()
+        @connection_config = connection_config
+        @query = query
+        @params = params
+        @row_identifier = row_identifier
+      end
+
+      # Executes the query and returns rows as hashes.
+      #
+      # @return [Array<Hash>]
+      def fetch
+        with_connection do |conn|
+          result = conn.exec_query(sanitize_query)
+          rows = result.to_a
+          @row_identifier ? rows.sort_by { |row| row[@row_identifier.to_s] } : rows
+        end
+      end
+
+      # @return [String]
+      def description
+        "Database Query: #{@query.to_s.tr("\n", " ")[0, 50]}"
+      end
+
+      private
+
+      def with_connection
+        ActiveRecord::Base.establish_connection(@connection_config)
+        ActiveRecord::Base.connection_pool.with_connection do |conn|
+          yield conn
+        end
+      ensure
+        ActiveRecord::Base.connection_pool.disconnect! if ActiveRecord::Base.connected?
+      end
+
+      def sanitize_query
+        ActiveRecord::Base.sanitize_sql_array([@query, @params])
+      end
+    end
+  end
+end

data/lib/regresso/adapters/database_snapshot.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module Regresso
+  module Adapters
+    # Adapter that collects full table snapshots from a database.
+    class DatabaseSnapshot < Base
+      # @param connection_config [Hash]
+      # @param tables [Array<String,Symbol>]
+      # @param where_clause [String,nil]
+      def initialize(connection_config:, tables:, where_clause: nil)
+        super()
+        @connection_config = connection_config
+        @tables = tables
+        @where_clause = where_clause
+      end
+
+      # Fetches rows for each table into a hash keyed by table name.
+      #
+      # @return [Hash{String => Array<Hash>}]
+      def fetch
+        with_connection do |conn|
+          @tables.each_with_object({}) do |table, acc|
+            query = "SELECT * FROM #{table}"
+            query += " WHERE #{@where_clause}" if @where_clause
+            acc[table.to_s] = conn.exec_query(query).to_a
+          end
+        end
+      end
+
+      # @return [String]
+      def description
+        "Database Snapshot: #{@tables.join(", ")}".strip
+      end
+
+      private
+
+      def with_connection
+        ActiveRecord::Base.establish_connection(@connection_config)
+        ActiveRecord::Base.connection_pool.with_connection do |conn|
+          yield conn
+        end
+      ensure
+        ActiveRecord::Base.connection_pool.disconnect! if ActiveRecord::Base.connected?
+      end
+    end
+  end
+end

data/lib/regresso/adapters/graphql.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Regresso
+  module Adapters
+    # Adapter that executes GraphQL queries over HTTP.
+    class GraphQL < Base
+      # @param endpoint [String]
+      # @param query [String]
+      # @param variables [Hash]
+      # @param headers [Hash]
+      # @param operation_name [String,nil]
+      def initialize(endpoint:, query:, variables: {}, headers: {}, operation_name: nil)
+        super()
+        @endpoint = endpoint
+        @query = query
+        @variables = variables
+        @headers = headers
+        @operation_name = operation_name
+      end
+
+      # Executes the GraphQL query and returns the data payload.
+      #
+      # @return [Object]
+      def fetch
+        response = connection.post do |req|
+          req.headers = default_headers.merge(@headers)
+          req.body = {
+            query: @query,
+            variables: @variables,
+            operationName: @operation_name
+          }.compact.to_json
+        end
+
+        data = response.body
+        raise GraphQLError, data["errors"] if data["errors"]&.any?
+
+        data["data"]
+      end
+
+      # @return [String]
+      def description
+        "GraphQL: #{@operation_name || "anonymous"}"
+      end
+
+      private
+
+      def connection
+        @connection ||= Faraday.new(url: @endpoint) do |faraday|
+          faraday.request :json
+          faraday.response :json
+          faraday.adapter Faraday.default_adapter
+        end
+      end
+
+      def default_headers
+        { "Content-Type" => "application/json", "Accept" => "application/json" }
+      end
+    end
+
+    # Raised when a GraphQL response contains errors.
+    class GraphQLError < StandardError
+      # @return [Array<Hash>]
+      attr_reader :errors
+
+      # @param errors [Array<Hash>]
+      def initialize(errors)
+        @errors = errors
+        super(errors.map { |error| error["message"] }.join(", "))
+      end
+    end
+  end
+end

data/lib/regresso/adapters/graphql_batch.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "regresso/adapters/graphql"
+
+module Regresso
+  module Adapters
+    # Adapter that runs multiple GraphQL queries and returns a keyed hash.
+    class GraphQLBatch < Base
+      # @param endpoint [String]
+      # @param queries [Array<Hash>]
+      # @param headers [Hash]
+      def initialize(endpoint:, queries:, headers: {})
+        super()
+        @endpoint = endpoint
+        @queries = queries
+        @headers = headers
+      end
+
+      # Executes all configured queries.
+      #
+      # @return [Hash{String => Object}]
+      def fetch
+        @queries.each_with_object({}) do |query, acc|
+          adapter = GraphQL.new(
+            endpoint: @endpoint,
+            query: query.fetch(:query),
+            variables: query[:variables] || {},
+            headers: @headers,
+            operation_name: query[:operation_name]
+          )
+
+          acc[query.fetch(:name).to_s] = adapter.fetch
+        end
+      end
+
+      # @return [String]
+      def description
+        "GraphQL Batch: #{@queries.size} queries"
+      end
+    end
+  end
+end

data/lib/regresso/adapters/http.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/follow_redirects"
+
+module Regresso
+  module Adapters
+    # Adapter that fetches data from an HTTP endpoint.
+    class Http < Base
+      # @param base_url [String]
+      # @param endpoint [String]
+      # @param params [Hash]
+      # @param headers [Hash]
+      # @param method [Symbol]
+      def initialize(base_url:, endpoint:, params: {}, headers: {}, method: :get)
+        super()
+        @base_url = base_url
+        @endpoint = endpoint
+        @params = params
+        @headers = headers
+        @method = method
+      end
+
+      # Executes the HTTP request and returns parsed response.
+      #
+      # @return [Object]
+      def fetch
+        response = connection.public_send(@method, @endpoint) do |req|
+          req.params = @params
+          req.headers = @headers
+        end
+
+        if response.status >= 400
+          raise Regresso::Error, "HTTP request failed with status #{response.status}"
+        end
+
+        parse_response(response)
+      end
+
+      # @return [String]
+      def description
+        "#{@method.to_s.upcase} #{@base_url}#{@endpoint}"
+      end
+
+      private
+
+      def connection
+        @connection ||= Faraday.new(url: @base_url) do |faraday|
+          faraday.request :json
+          faraday.response :json
+          faraday.response :follow_redirects
+          faraday.adapter Faraday.default_adapter
+        end
+      end
+
+      def parse_response(response)
+        content_type = response.headers["content-type"].to_s
+        return response.body if content_type.empty?
+
+        if content_type.match?(/json/)
+          response.body
+        elsif content_type.match?(/csv/)
+          response.body
+        else
+          response.body
+        end
+      end
+    end
+  end
+end

data/lib/regresso/adapters/json_file.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Regresso
+  module Adapters
+    # Adapter that loads JSON content from a file.
+    class JsonFile < Base
+      # @param path [String]
+      def initialize(path:)
+        super()
+        @path = path
+      end
+
+      # Loads JSON from the file.
+      #
+      # @return [Object]
+      def fetch
+        raise Errno::ENOENT, @path unless File.exist?(@path)
+
+        JSON.parse(File.read(@path))
+      end
+
+      # @return [String]
+      def description
+        "JSON File: #{@path}"
+      end
+    end
+  end
+end

data/lib/regresso/adapters/proc.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Regresso
+  module Adapters
+    # Adapter that calls a provided Proc or block for data.
+    class Proc < Base
+      # @param callable [Proc,nil]
+      # @param description [String]
+      def initialize(callable = nil, description: "Custom source", &block)
+        super()
+        @callable = callable || block
+        @description_text = description
+      end
+
+      # Executes the callable and returns its value.
+      #
+      # @return [Object]
+      def fetch
+        raise ArgumentError, "callable is required" unless @callable
+
+        @callable.call
+      end
+
+      # @return [String]
+      def description
+        @description_text
+      end
+    end
+  end
+end

data/lib/regresso/ci/github_annotation_formatter.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Regresso
+  module CI
+    # Formats parallel results into GitHub Actions annotations.
+    class GitHubAnnotationFormatter
+      # @param result [Regresso::Parallel::ParallelResult]
+      def initialize(result)
+        @result = result
+      end
+
+      # @return [Array<Hash>] GitHub annotations payload
+      def annotations
+        @result.results.map do |res|
+          next unless res.failed? || res.error?
+
+          {
+            title: "Regresso: #{res.name}",
+            file: "regresso",
+            line: 1,
+            end_line: 1,
+            annotation_level: "error",
+            message: annotation_message(res)
+          }
+        end.compact
+      end
+
+      # @return [String] GitHub Actions workflow annotation output
+      def output_for_workflow
+        annotations.map do |annotation|
+          "::error file=#{annotation[:file]},line=#{annotation[:line]}::#{annotation[:message]}"
+        end.join("\n")
+      end
+
+      private
+
+      def annotation_message(res)
+        if res.failed?
+          "Regression detected"
+        else
+          "Error: #{res.error.class} - #{res.error.message}"
+        end
+      end
+    end
+  end
+end

data/lib/regresso/ci/github_pr_commenter.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "octokit"
+
+module Regresso
+  module CI
+    # Posts a summary comment to a GitHub pull request.
+    class GitHubPRCommenter
+      # @param token [String]
+      # @param repo [String]
+      # @param pr_number [Integer]
+      def initialize(token:, repo:, pr_number:)
+        @client = Octokit::Client.new(access_token: token)
+        @repo = repo
+        @pr_number = pr_number
+      end
+
+      # Creates or updates a PR comment with the report summary.
+      #
+      # @param result [Regresso::Parallel::ParallelResult]
+      # @return [void]
+      def post_comment(result)
+        body = build_comment_body(result)
+        existing = find_existing_comment
+        if existing
+          @client.update_comment(@repo, existing.id, body)
+        else
+          @client.add_comment(@repo, @pr_number, body)
+        end
+      end
+
+      private
+
+      def find_existing_comment
+        @client.issue_comments(@repo, @pr_number).find do |comment|
+          comment.body.include?("<!-- regresso-report -->")
+        end
+      end
+
+      def build_comment_body(result)
+        <<~MARKDOWN
+          <!-- regresso-report -->
+          ## Regresso Report
+
+          | Status | Count |
+          |--------|-------|
+          | Passed | #{result.passed} |
+          | Failed | #{result.failed} |
+          | Errors | #{result.errors} |
+          | Total | #{result.total} |
+        MARKDOWN
+      end
+    end
+  end
+end

data/lib/regresso/ci/junit_xml_formatter.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "builder"
+
+module Regresso
+  module CI
+    # Formats parallel results into JUnit XML.
+    class JUnitXmlFormatter
+      # @param result [Regresso::Parallel::ParallelResult]
+      def initialize(result)
+        @result = result
+      end
+
+      # @return [String] JUnit XML payload
+      def format
+        builder = Builder::XmlMarkup.new(indent: 2)
+        builder.instruct!
+
+        builder.testsuites(
+          name: "Regresso Regression Tests",
+          tests: @result.total,
+          failures: @result.failed,
+          errors: @result.errors
+        ) do |suites|
+          suites.testsuite(name: "Regression", tests: @result.total) do |suite|
+            @result.results.each do |res|
+              suite.testcase(name: res.name, time: res.duration) do |tc|
+                if res.failed?
+                  tc.failure(message: "Regression detected", type: "RegressionFailure")
+                elsif res.error?
+                  tc.error(message: res.error.message, type: res.error.class.name)
+                end
+              end
+            end
+          end
+        end
+
+        builder.target!
+      end
+    end
+  end
+end

data/lib/regresso/ci/reporter.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Regresso
+  # CI-related reporting helpers.
+  module CI
+    # Builds CI-friendly reports from parallel results.
+    class Reporter
+      # @param result [Regresso::Parallel::ParallelResult]
+      def initialize(result)
+        @result = result
+      end
+
+      # @return [String] JUnit XML output
+      def to_junit_xml
+        JUnitXmlFormatter.new(@result).format
+      end
+
+      # @return [Array<Hash>] GitHub annotations payload
+      def to_github_annotations
+        GitHubAnnotationFormatter.new(@result).annotations
+      end
+
+      # @return [Hash] GitLab report payload
+      def to_gitlab_report
+        {
+          total: @result.total,
+          passed: @result.passed,
+          failed: @result.failed,
+          errors: @result.errors,
+          results: @result.results.map do |res|
+            {
+              name: res.name,
+              status: res.status,
+              duration: res.duration
+            }
+          end
+        }
+      end
+
+      # Writes JUnit XML output to a file.
+      #
+      # @param path [String]
+      # @return [void]
+      def write_junit_xml(path)
+        File.write(path, to_junit_xml)
+      end
+    end
+  end
+end

data/lib/regresso/ci.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "ci/junit_xml_formatter"
+require_relative "ci/github_annotation_formatter"
+require_relative "ci/github_pr_commenter"
+require_relative "ci/reporter"