quality_gate 0.1.0

data/lib/quality_gate/installer.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "installation"
+require_relative "ruby_profile"
+
+module QualityGate
+  # Installs the framework-independent Quality Gate files into a Ruby project.
+  class Installer
+    include Installation
+
+    VALID_OPTIONS = %i[
+      profile
+      test_framework
+      test_helper
+      test_command
+      agents
+      pretend
+      skip_coverage
+    ].freeze
+    DEFAULT_TEMPLATE_ROOT = File.expand_path("../generators/quality_gate/install/templates", __dir__).freeze
+    INSTALL_STEPS = %i[
+      create_settings_file
+      create_rules_file
+      create_initializers
+      inject_coverage
+      create_agent_integration
+    ].freeze
+
+    attr_reader :destination_root, :stdout, :profile
+
+    def initialize(destination_root:, options: {}, stdout: $stdout)
+      @options = normalize_options(options)
+      @profile = RubyProfile.new(destination_root:, options: @options)
+      @destination_root = @profile.destination_root
+      @stdout = stdout
+      @template_source_root = DEFAULT_TEMPLATE_ROOT
+    end
+
+    def options
+      @options.merge(skip_initializers: true)
+    end
+
+    def call
+      INSTALL_STEPS.each { |step| public_send(step) }
+      print_summary
+
+      results.fetch(:needs_person, []).empty? ? 0 : 1
+    end
+
+    def behavior
+      :invoke
+    end
+
+    def test_helper_path
+      profile.test_helper
+    end
+
+    def template_for(name)
+      profile.template_for(name)
+    end
+
+    private
+
+    attr_reader :template_source_root
+
+    def normalize_options(value)
+      normalized = option_pairs(value).to_h
+      validate_options!(normalized)
+      normalized.freeze
+    end
+
+    def option_pairs(value)
+      raise ArgumentError, "options must be a mapping" unless value.respond_to?(:to_h)
+
+      value.to_h.map { |key, option_value| [key.to_sym, option_value] }
+    rescue TypeError, NoMethodError
+      raise ArgumentError, "option keys must be symbols or strings"
+    end
+
+    def validate_options!(normalized)
+      unknown = normalized.keys - VALID_OPTIONS
+      return if unknown.empty?
+
+      raise ArgumentError, "unknown installer option(s): #{unknown.map(&:inspect).join(", ")}"
+    end
+
+    def create_new_file(relative_path, content)
+      write_new_file(File.join(destination_root, relative_path), content)
+    end
+
+    def write_new_file(path, content)
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, File::WRONLY | File::CREAT | File::EXCL, 0o644) do |file|
+        file.binmode
+        file.write(content)
+      end
+    end
+
+    def say(message)
+      stdout.puts(message)
+    end
+  end
+end

data/lib/quality_gate/railtie.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+if defined?(Rails::Railtie)
+  module QualityGate
+    # Integrates Quality Gate's generator and task files with Rails applications.
+    class Railtie < Rails::Railtie
+      generators do
+        require_relative "../generators/quality_gate/install/install_generator"
+      end
+
+      rake_tasks do
+        Dir[File.expand_path("../tasks/**/*.rake", __dir__)].sort.each { load _1 }
+      end
+    end
+  end
+end

data/lib/quality_gate/reporters/field_sanitizer.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module QualityGate
+  module Reporters
+    # Normalizes reporter string fields without mutating source findings.
+    module FieldSanitizer
+      REPLACEMENT_CHARACTER = "\uFFFD"
+
+      module_function
+
+      def for_text(value)
+        sanitize_text(scrub_utf8(value), preserve_newlines: false)
+      end
+
+      def for_text_message(value)
+        sanitize_text(scrub_utf8(value), preserve_newlines: true)
+      end
+
+      def for_json(value)
+        scrub_utf8(value)
+      end
+
+      def scrub_utf8(value)
+        value.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: REPLACEMENT_CHARACTER)
+      end
+
+      def sanitize_text(value, preserve_newlines:)
+        value.each_char.map { sanitize_character(_1, preserve_newlines) }.join.strip
+      end
+
+      def sanitize_character(character, preserve_newlines)
+        return character if preserve_newlines && character == "\n"
+        return "" if preserve_newlines && character == "\e"
+        return character unless character.match?(/[[:cntrl:]\u2028\u2029]/)
+
+        " "
+      end
+    end
+
+    private_constant :FieldSanitizer
+  end
+end

data/lib/quality_gate/reporters/json.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "json"
+
+module QualityGate
+  module Reporters
+    # Writes machine-readable reports as one JSON object per run.
+    class Json
+      def initialize(io:)
+        @io = io
+      end
+
+      def call(result)
+        io.puts(::JSON.generate(payload_for(result)))
+      end
+
+      private
+
+      attr_reader :io
+
+      def payload_for(result)
+        {
+          "checks" => result.checks.map { serialize_check(_1) },
+          "findings" => result.findings.map { serialize_finding(_1) },
+          "summary" => {
+            "findings" => result.findings.length,
+            "tool_failures" => result.failed_tools.length,
+            "failed_tools" => result.failed_tools.map { FieldSanitizer.for_json(_1) }
+          }
+        }
+      end
+
+      def serialize_finding(finding)
+        {
+          "tool" => FieldSanitizer.for_json(finding.tool),
+          "file" => FieldSanitizer.for_json(finding.file),
+          "line" => finding.line,
+          "rule" => FieldSanitizer.for_json(finding.rule),
+          "severity" => FieldSanitizer.for_json(finding.severity.to_s),
+          "message" => FieldSanitizer.for_json(finding.message)
+        }
+      end
+
+      def serialize_check(check)
+        {
+          "tool" => FieldSanitizer.for_json(check_value(check, :tool)),
+          "status" => FieldSanitizer.for_json(check_value(check, :status)),
+          "scope" => FieldSanitizer.for_json(check_value(check, :scope)),
+          "requested_files" => check_value(check, :requested_files).map { FieldSanitizer.for_json(_1) },
+          "duration_ms" => check_value(check, :duration_ms)
+        }
+      end
+
+      def check_value(check, key)
+        check.fetch(key) { check.fetch(key.to_s) }
+      end
+    end
+  end
+end

data/lib/quality_gate/reporters/text.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module QualityGate
+  module Reporters
+    # Writes line-oriented reports for humans.
+    class Text
+      def initialize(io:)
+        @io = io
+      end
+
+      def call(result)
+        result.findings.each do |finding|
+          io.puts(render_finding(finding))
+        end
+
+        io.puts("#{result.findings.length} findings, #{result.failed_tools.length} tool failures")
+      end
+
+      private
+
+      attr_reader :io
+
+      def render_finding(finding)
+        lines = FieldSanitizer.for_text_message(finding.message).split("\n", -1)
+        ["#{finding_prefix(finding)} #{lines.first}", *lines.drop(1).map { "  #{_1}" }].join("\n")
+      end
+
+      def finding_prefix(finding)
+        [
+          FieldSanitizer.for_text(finding.tool),
+          FieldSanitizer.for_text(finding.severity.to_s),
+          finding_location(finding),
+          FieldSanitizer.for_text(finding.rule)
+        ].compact.join(" ")
+      end
+
+      def finding_location(finding)
+        file = FieldSanitizer.for_text(finding.file)
+        return if file.empty?
+
+        finding.line.zero? ? file : "#{file}:#{finding.line}"
+      end
+    end
+  end
+end

data/lib/quality_gate/rubocop.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "rubocop"
+require "lint_roller"
+require_relative "version"
+require_relative "../rubocop/cop/quality_gate/association_default_block_value"
+require_relative "../rubocop/cop/quality_gate/prefer_after_save_commit"
+require_relative "../rubocop/cop/quality_gate/private_only_concern"
+require_relative "../rubocop/cop/quality_gate/broadcast_in_controller"
+require_relative "../rubocop/cop/quality_gate/controller_instance_variables"
+
+module QualityGate
+  # Loads optional Rails conventions through RuboCop's plugin interface.
+  class RuboCopPlugin < LintRoller::Plugin
+    def about
+      LintRoller::About.new(
+        name: "quality_gate", version: VERSION,
+        homepage: "https://github.com/lucianghinda/quality_gate",
+        description: "Conservative, opt-in Rails convention checks."
+      )
+    end
+
+    def supported?(context)
+      context.engine == :rubocop
+    end
+
+    def rules(_context)
+      LintRoller::Rules.new(
+        type: :path, config_format: :rubocop,
+        value: Pathname.new(File.expand_path("../../config/cops.yml", __dir__))
+      )
+    end
+  end
+end

data/lib/quality_gate/ruby_profile.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "json"
+require "shellwords"
+
+module QualityGate
+  module RubyProfileSupport
+    DEFAULT_COMMANDS = {
+      "minitest" => %w[bundle exec rake test].freeze,
+      "rspec" => %w[bundle exec rspec].freeze
+    }.freeze
+    private_constant :DEFAULT_COMMANDS
+
+    module_function
+
+    def options(value)
+      raise ArgumentError, "options must be a mapping" unless value.respond_to?(:to_h)
+
+      value.to_h.transform_keys(&:to_sym)
+    rescue NoMethodError
+      raise ArgumentError, "option keys must be symbols or strings"
+    end
+
+    def destination_root(value)
+      path = value.to_s
+      raise ArgumentError, "destination_root must be a non-empty directory" if path.empty?
+
+      expanded = File.expand_path(path)
+      return expanded if File.directory?(expanded)
+
+      raise ArgumentError, "destination_root must be an existing directory: #{path}"
+    end
+
+    def relative_path(root_path, value, name)
+      validate_path_value!(value, name)
+      raise ArgumentError, "#{name} must be relative to the project" if Pathname.new(value).absolute?
+
+      relative = Pathname.new(File.expand_path(value, root_path)).relative_path_from(Pathname.new(root_path)).to_s
+      return relative unless outside_project?(relative)
+
+      raise ArgumentError, "#{name} must stay inside the project"
+    end
+
+    def command(value, framework)
+      command = value.nil? ? DEFAULT_COMMANDS.fetch(framework) : parse_command(value)
+      validate_command!(command)
+      command.map(&:dup).freeze
+    end
+
+    def parse_command(value)
+      return value.dup if value.is_a?(Array)
+      return parse_shellwords(value) if value.is_a?(String)
+
+      raise ArgumentError, "test_command must be a command string or argv array"
+    end
+
+    def parse_shellwords(value)
+      Shellwords.split(value)
+    rescue ArgumentError => e
+      raise ArgumentError, "test_command could not be parsed: #{e.message}"
+    end
+
+    def validate_path_value!(value, name)
+      return if value.is_a?(String) && !value.empty?
+
+      raise ArgumentError, "#{name} must be a non-empty path"
+    end
+
+    def validate_command!(command)
+      valid = command.is_a?(Array) && command.any? && command.all? { _1.is_a?(String) && !_1.empty? }
+      return if valid
+
+      raise ArgumentError, "test_command must not be empty"
+    end
+
+    def outside_project?(relative)
+      relative == ".." || relative.start_with?("../")
+    end
+  end
+  private_constant :RubyProfileSupport
+
+  # Resolves the framework, helper, command, and templates for a plain Ruby project.
+  class RubyProfile
+    DEFAULT_HELPERS = {
+      "minitest" => "test/test_helper.rb",
+      "rspec" => "spec/spec_helper.rb"
+    }.freeze
+    TEMPLATE_MAP = {
+      "quality_gate.yml.tt" => "ruby_quality_gate.yml.tt",
+      "rubocop.yml.tt" => "ruby_rubocop.yml.tt",
+      "simplecov.rb.tt" => "ruby_simplecov.rb.tt",
+      "agents_section.md.tt" => "ruby_agents_section.md.tt"
+    }.freeze
+    SUPPORTED_FRAMEWORKS = DEFAULT_HELPERS.keys.freeze
+    private_constant :DEFAULT_HELPERS, :TEMPLATE_MAP, :SUPPORTED_FRAMEWORKS
+
+    attr_reader :destination_root, :test_helper, :test_command
+
+    def initialize(destination_root:, options: {})
+      @destination_root = RubyProfileSupport.destination_root(destination_root)
+      @options = RubyProfileSupport.options(options)
+      resolve_settings
+    end
+
+    def coverage? = @coverage
+
+    def template_for(name)
+      TEMPLATE_MAP.fetch(name, name)
+    end
+
+    private
+
+    attr_reader :options, :framework
+
+    def resolve_settings
+      validate_profile!
+      @coverage = !option(:skip_coverage)
+      @framework = resolve_framework
+      @test_helper = resolve_test_helper
+      @test_command = RubyProfileSupport.command(option(:test_command), framework)
+    end
+
+    def option(key)
+      options.fetch(key, nil)
+    end
+
+    def validate_profile!
+      return if (option(:profile) || "ruby").to_s == "ruby"
+
+      raise ArgumentError, "unsupported profile; only ruby is supported"
+    end
+
+    def resolve_framework
+      explicit = option(:test_framework)
+      return validate_framework(explicit) if explicit
+      return "minitest" if option(:test_helper)
+
+      detected_framework
+    end
+
+    def validate_framework(value)
+      framework = value.to_s
+      return framework if SUPPORTED_FRAMEWORKS.include?(framework)
+
+      raise ArgumentError, "test_framework must be minitest or rspec"
+    end
+
+    def detected_framework
+      available = DEFAULT_HELPERS.select { |_framework, helper| helper_present?(helper) }.keys
+      return available.first if available.one?
+      return "minitest" if available.empty?
+
+      raise ArgumentError, "both test helpers exist; pass --test-framework minitest or rspec"
+    end
+
+    def helper_present?(helper)
+      File.file?(File.join(destination_root, helper))
+    end
+
+    def resolve_test_helper
+      helper = option(:test_helper) || DEFAULT_HELPERS.fetch(framework)
+      relative = RubyProfileSupport.relative_path(destination_root, helper, "test_helper")
+      return relative if !coverage? || helper_present?(relative)
+
+      raise ArgumentError,
+            "test helper #{relative.inspect} does not exist; pass --skip-coverage or provide an existing helper"
+    end
+  end
+end

data/lib/quality_gate/runner.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module QualityGate
+  module RunnerValueCopy
+    module_function
+
+    def freeze_copy(value)
+      case value
+      when Array
+        value.map { freeze_copy(_1) }.freeze
+      when Hash
+        value.each_with_object({}) do |(key, child), copy|
+          copy[freeze_copy(key)] = freeze_copy(child)
+        end.freeze
+      when String
+        value.dup.freeze
+      else
+        value
+      end
+    end
+  end
+  private_constant :RunnerValueCopy
+
+  # Runs adapters in order and reduces their findings into one immutable result.
+  class Runner
+    Result = Data.define(:findings, :failed_tools, :checks) do
+      def initialize(findings:, checks: [])
+        copied_findings = findings.dup.freeze
+        failed_tools = copied_findings.select(&:tool_failure?).map(&:tool).uniq
+        copied_checks = RunnerValueCopy.freeze_copy(checks)
+
+        super(
+          findings: copied_findings,
+          failed_tools: failed_tools.map { _1.dup.freeze }.freeze,
+          checks: copied_checks
+        )
+      end
+
+      # Override Data#with so replacements cannot bypass the derived-state invariant.
+      def with(findings: self.findings, checks: self.checks)
+        self.class.new(findings: findings, checks: checks)
+      end
+
+      def exit_code
+        return ExitCode::TOOL_FAILURE if failed_tools.any?
+        return ExitCode::FINDINGS if findings.any?
+
+        ExitCode::CLEAN
+      end
+    end
+
+    CHECK_SCOPES = {
+      "rubocop" => "selected_files",
+      "reek" => "selected_files",
+      "test_suite" => "test_suite",
+      "undercover" => "git_diff",
+      "simplecov" => "coverage_summary",
+      "brakeman" => "project",
+      "bundler_audit" => "lockfile"
+    }.freeze
+    SELECTION_SUPPORTED_TOOLS = %w[rubocop reek].freeze
+    private_constant :CHECK_SCOPES, :SELECTION_SUPPORTED_TOOLS
+
+    def initialize(adapters:, config:, diagnostic_io: nil)
+      @adapters = adapters.dup.freeze
+      @config = config
+      @diagnostic_io = diagnostic_io
+    end
+
+    def call
+      findings = []
+      checks = []
+
+      adapters.each do |adapter|
+        tool = adapter_name(adapter)
+        write_progress(tool, scope_for(tool))
+        started_at = monotonic_time
+        adapter_findings = adapter.call
+        findings.concat(adapter_findings)
+        checks << check_for(tool, adapter_findings, elapsed_ms_since(started_at))
+      end
+
+      Result.new(findings:, checks:)
+    end
+
+    private
+
+    attr_reader :adapters, :config, :diagnostic_io
+
+    def adapter_name(adapter)
+      adapter.name.to_s
+    end
+
+    def check_for(tool, findings, duration_ms)
+      {
+        tool: tool,
+        status: status_for(findings),
+        scope: scope_for(tool),
+        requested_files: selection_supported?(tool) ? requested_files : [],
+        duration_ms: duration_ms
+      }
+    end
+
+    def selection_supported?(tool)
+      SELECTION_SUPPORTED_TOOLS.include?(tool)
+    end
+
+    def scope_for(tool)
+      scope = CHECK_SCOPES.fetch(tool, "unknown")
+      return "project" if scope == "selected_files" && requested_files.empty?
+
+      scope
+    end
+
+    def requested_files
+      config.fetch(:files).map(&:to_s)
+    end
+
+    def status_for(findings)
+      return "tool_failure" if findings.any?(&:tool_failure?)
+      return "skipped" if findings.any? { _1.rule == "undercover_skipped" }
+      return "findings" if findings.any?
+
+      "clean"
+    end
+
+    def elapsed_ms_since(started_at)
+      [(monotonic_time - started_at) * 1000, 0].max.round
+    end
+
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def write_progress(tool, scope)
+      return unless diagnostic_io
+
+      diagnostic_io.puts("Running #{sanitize_progress(tool)} (scope: #{scope})...")
+    rescue StandardError
+      nil
+    end
+
+    def sanitize_progress(value)
+      value.to_s
+           .encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "�")
+           .gsub(/(?:[[:cntrl:]]|[\u2028\u2029])+/, " ")
+           .strip
+    end
+  end
+end

data/lib/quality_gate/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module QualityGate
+  VERSION = "0.1.0"
+end

data/lib/quality_gate.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "quality_gate/version"
+require_relative "quality_gate/exit_code"
+require_relative "quality_gate/finding"
+require_relative "quality_gate/reporters/field_sanitizer"
+require_relative "quality_gate/reporters/json"
+require_relative "quality_gate/reporters/text"
+require_relative "quality_gate/hook_log"
+
+module QualityGate
+  class Error < StandardError; end
+  # Your code goes here...
+end
+
+require_relative "quality_gate/adapter"
+require_relative "quality_gate/adapters/brakeman"
+require_relative "quality_gate/adapters/bundler_audit"
+require_relative "quality_gate/adapters/reek"
+require_relative "quality_gate/adapters/rubocop"
+require_relative "quality_gate/adapters/simplecov"
+require_relative "quality_gate/adapters/test_suite"
+require_relative "quality_gate/adapters/undercover"
+require_relative "quality_gate/config"
+require_relative "quality_gate/runner"
+require_relative "quality_gate/cli"
+require_relative "quality_gate/railtie" if defined?(Rails::Railtie)