reviewer 0.1.4 → 1.0.0

data/lib/reviewer/setup/catalog.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module Reviewer
+  module Setup
+    # Frozen hash of known tool definitions with detection signals.
+    # Each entry contains the config structure needed for .reviewer.yml
+    # plus a :detect key with signals for auto-detection.
+    module Catalog
+      # Known tool definitions with detection signals and default configuration
+      TOOLS = {
+        bundle_audit: {
+          name: 'Bundle Audit',
+          description: 'Review gem dependencies for security issues',
+          tags: %w[security dependencies ruby],
+          commands: {
+            install: 'bundle exec gem install bundler-audit',
+            prepare: 'bundle exec bundle-audit update',
+            review: 'bundle exec bundle-audit check --no-update'
+          },
+          detect: {
+            gems: %w[bundler-audit]
+          }
+        },
+        rubocop: {
+          name: 'RuboCop',
+          description: 'Review Ruby syntax and formatting for consistency',
+          tags: %w[ruby syntax],
+          commands: {
+            install: 'bundle exec gem install rubocop',
+            review: 'bundle exec rubocop --parallel',
+            format: 'bundle exec rubocop --auto-correct'
+          },
+          files: { flag: '', separator: ' ', pattern: '*.rb' },
+          detect: {
+            gems: %w[rubocop],
+            files: %w[.rubocop.yml]
+          }
+        },
+        standard: {
+          name: 'Standard',
+          description: 'Zero-configuration Ruby linter',
+          tags: %w[ruby syntax],
+          commands: {
+            review: 'bundle exec standardrb',
+            format: 'bundle exec standardrb --fix'
+          },
+          detect: {
+            gems: %w[standard]
+          }
+        },
+        reek: {
+          name: 'Reek',
+          description: 'Examine Ruby classes for code smells',
+          tags: %w[ruby quality],
+          commands: {
+            install: 'bundle exec gem install reek',
+            review: 'bundle exec reek'
+          },
+          files: { flag: '', separator: ' ', pattern: '*.rb' },
+          detect: {
+            gems: %w[reek],
+            files: %w[.reek.yml]
+          }
+        },
+        flog: {
+          name: 'Flog',
+          description: 'Reports the most tortured Ruby code in a pain report',
+          tags: %w[ruby quality],
+          commands: {
+            install: 'bundle exec gem install flog',
+            review: 'bundle exec flog -g lib'
+          },
+          detect: {
+            gems: %w[flog]
+          }
+        },
+        flay: {
+          name: 'Flay',
+          description: 'Review Ruby code for structural similarities',
+          tags: %w[ruby quality],
+          commands: {
+            install: 'bundle exec gem install flay',
+            review: 'bundle exec flay ./lib'
+          },
+          detect: {
+            gems: %w[flay]
+          }
+        },
+        brakeman: {
+          name: 'Brakeman',
+          description: 'Static analysis security scanner for Rails',
+          tags: %w[security ruby],
+          commands: {
+            install: 'bundle exec gem install brakeman',
+            review: 'bundle exec brakeman --no-pager -q'
+          },
+          detect: {
+            gems: %w[brakeman],
+            directories: %w[app/controllers]
+          }
+        },
+        fasterer: {
+          name: 'Fasterer',
+          description: 'Suggest performance improvements for Ruby code',
+          tags: %w[ruby quality performance],
+          commands: {
+            install: 'bundle exec gem install fasterer',
+            review: 'bundle exec fasterer'
+          },
+          files: { flag: '', separator: ' ', pattern: '*.rb' },
+          detect: {
+            gems: %w[fasterer]
+          }
+        },
+        tests: {
+          name: 'Minitest',
+          description: 'Unit tests and coverage',
+          tags: %w[ruby tests],
+          commands: {
+            review: 'bundle exec rake test'
+          },
+          files: { review: 'bundle exec ruby -Itest', pattern: '*_test.rb', map_to_tests: 'minitest' },
+          detect: {
+            gems: %w[minitest],
+            directories: %w[test]
+          }
+        },
+        specs: {
+          name: 'RSpec',
+          description: 'Behavior-driven tests and coverage',
+          tags: %w[ruby tests],
+          commands: {
+            review: 'bundle exec rspec'
+          },
+          files: { flag: '', separator: ' ', pattern: '*_spec.rb', map_to_tests: 'rspec' },
+          detect: {
+            gems: %w[rspec],
+            directories: %w[spec]
+          }
+        },
+        eslint: {
+          name: 'ESLint',
+          description: 'Lint JavaScript and TypeScript code',
+          tags: %w[javascript linting syntax],
+          commands: {
+            review: 'npx eslint .',
+            format: 'npx eslint . --fix'
+          },
+          files: { flag: '', separator: ' ', pattern: '*.js' },
+          detect: {
+            files: %w[.eslintrc .eslintrc.js .eslintrc.json .eslintrc.yml eslint.config.js eslint.config.mjs]
+          }
+        },
+        prettier: {
+          name: 'Prettier',
+          description: 'Check code formatting consistency',
+          tags: %w[javascript formatting],
+          commands: {
+            review: 'npx prettier --check .',
+            format: 'npx prettier --write .'
+          },
+          detect: {
+            files: %w[.prettierrc .prettierrc.js .prettierrc.json .prettierrc.yml .prettierrc.yaml]
+          }
+        },
+        stylelint: {
+          name: 'Stylelint',
+          description: 'Lint CSS and SCSS for errors and consistency',
+          tags: %w[css linting],
+          commands: {
+            review: 'npx stylelint "**/*.css"',
+            format: 'npx stylelint "**/*.css" --fix'
+          },
+          files: { flag: '', separator: ' ', pattern: '*.css' },
+          detect: {
+            files: %w[.stylelintrc .stylelintrc.js .stylelintrc.json .stylelintrc.yml]
+          }
+        },
+        typescript: {
+          name: 'TypeScript',
+          description: 'Type-check TypeScript code',
+          tags: %w[javascript typescript],
+          commands: {
+            review: 'npx tsc --noEmit'
+          },
+          detect: {
+            files: %w[tsconfig.json]
+          }
+        },
+        biome: {
+          name: 'Biome',
+          description: 'Lint and format JavaScript and TypeScript',
+          tags: %w[javascript linting formatting],
+          commands: {
+            review: 'npx @biomejs/biome check .',
+            format: 'npx @biomejs/biome check . --fix'
+          },
+          files: { flag: '', separator: ' ', pattern: '*.js' },
+          detect: {
+            files: %w[biome.json biome.jsonc]
+          }
+        }
+      }.freeze
+
+      # Returns the full catalog of known tools
+      #
+      # @return [Hash] frozen hash of tool definitions
+      def self.all = TOOLS
+
+      # Returns the config for a tool key without the :detect key
+      #
+      # @param key [Symbol] the tool key
+      # @return [Hash, nil] config hash without :detect, or nil if not found
+      def self.config_for(key)
+        definition = TOOLS[key]
+        return nil unless definition
+
+        definition.except(:detect)
+      end
+
+      # Returns the detection signals for a tool key
+      #
+      # @param key [Symbol] the tool key
+      # @return [Hash, nil] detect hash, or nil if not found
+      def self.detect_for(key)
+        definition = TOOLS[key]
+        return nil unless definition
+
+        definition[:detect]
+      end
+    end
+  end
+end

data/lib/reviewer/setup/detector.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Reviewer
+  module Setup
+    # Scans a project directory to detect which review tools are applicable
+    # based on Gemfile.lock contents, config files, and directory structure.
+    class Detector
+      # Value object for a single detection result (tool key + evidence).
+      # @!attribute key [rw]
+      #   @return [Symbol] the tool identifier from the catalog
+      # @!attribute reasons [rw]
+      #   @return [Array<String>] evidence strings explaining why the tool was detected
+      Result = Struct.new(:key, :reasons, keyword_init: true) do
+        # @return [String] human-readable tool name from the catalog, or the key as fallback
+        def name = Catalog.config_for(key)&.dig(:name) || key.to_s
+        # @return [String] formatted line for display (name + reasons)
+        def summary = "  #{name.ljust(22)}#{reasons.join(', ')}"
+      end
+
+      attr_reader :project_dir
+
+      # Creates a detector for scanning a project directory for supported tools
+      # @param project_dir [Pathname, String] the project root to scan
+      #
+      # @return [Detector]
+      def initialize(project_dir = Pathname.pwd)
+        @project_dir = Pathname(project_dir)
+      end
+
+      # Scans the project and returns detection results for matching tools
+      #
+      # @return [Array<Result>] detected tools with evidence
+      def detect
+        gems = GemfileLock.new(project_dir.join('Gemfile.lock')).gem_names
+
+        Catalog.all.filter_map do |key, definition|
+          reasons = reasons_for(definition[:detect], gems)
+          Result.new(key: key, reasons: reasons) if reasons.any?
+        end
+      end
+
+      private
+
+      def reasons_for(detect, gems)
+        gem_reasons(detect, gems) + file_reasons(detect) + directory_reasons(detect)
+      end
+
+      def gem_reasons(detect, gems)
+        Array(detect[:gems]).select { |name| gems.include?(name) }.map { |name| "#{name} in Gemfile.lock" }
+      end
+
+      def file_reasons(detect)
+        Array(detect[:files]).select { |name| project_dir.join(name).exist? }
+      end
+
+      def directory_reasons(detect)
+        Array(detect[:directories]).select { |name| project_dir.join(name).directory? }.map { |name| "#{name}/ directory" }
+      end
+    end
+  end
+end

data/lib/reviewer/setup/formatter.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative '../output/formatting'
+
+module Reviewer
+  module Setup
+    # Display logic for the first-run setup flow
+    class Formatter
+      include Output::Formatting
+
+      attr_reader :output, :printer
+      private :output, :printer
+
+      # Creates a formatter for setup flow display
+      # @param output [Output] the console output handler
+      #
+      # @return [Formatter]
+      def initialize(output)
+        @output = output
+        @printer = output.printer
+      end
+
+      # Displays the welcome message when Reviewer has no configuration file
+      #
+      # @return [void]
+      def first_run_greeting
+        output.newline
+        printer.puts(:bold, "It looks like you're setting up Reviewer for the first time on this project.")
+        output.newline
+        printer.puts(:muted, 'This will auto-detect your tools and generate a .reviewer.yml configuration file.')
+        output.newline
+      end
+
+      # Displays a hint about `rvw init` when the user declines initial setup
+      #
+      # @return [void]
+      def first_run_skip
+        printer.puts(:muted, 'You can run `rvw init` any time to auto-detect and configure your tools.')
+        output.newline
+      end
+
+      # Displays a notice when `rvw init` is run but .reviewer.yml already exists
+      # @param config_file [Pathname] the existing configuration file path
+      #
+      # @return [void]
+      def setup_already_exists(config_file)
+        output.newline
+        printer.puts(:bold, "Configuration already exists: #{config_file.basename}")
+        output.newline
+        printer.puts(:muted, 'Run `rvw doctor` for a diagnostic report.')
+        printer.puts(:muted, 'To regenerate, remove the file and run `rvw init` again.')
+        output.newline
+      end
+
+      # Displays a message when auto-detection finds no supported tools in the project
+      #
+      # @return [void]
+      def setup_no_tools_detected
+        output.newline
+        printer.puts(:bold, 'No supported tools detected.')
+        output.newline
+        printer.puts(:muted, 'Create .reviewer.yml manually:')
+        printer.puts(:muted, "  #{Setup::CONFIG_URL}")
+        output.newline
+      end
+
+      # Displays the results of a successful setup with the detected tools
+      # @param results [Array<Detector::Result>] the tools that were detected and configured
+      #
+      # @return [void]
+      def setup_success(results)
+        output.newline
+        printer.puts(:success, 'Created .reviewer.yml')
+        print_detected_tools(results)
+        print_setup_footer
+      end
+
+      private
+
+      def print_detected_tools(results)
+        output.newline
+        printer.puts(:bold, 'Detected tools:')
+        results.each { |result| printer.puts(:default, result.summary) }
+      end
+
+      def print_setup_footer
+        output.newline
+        printer.puts(:muted, "Configure further:    #{Setup::CONFIG_URL}")
+        printer.puts(:muted, 'Run `rvw` to review your code.')
+        output.newline
+      end
+    end
+  end
+end

data/lib/reviewer/setup/gemfile_lock.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Reviewer
+  module Setup
+    # Parses a Gemfile.lock to extract gem names from the specs section
+    class GemfileLock
+      # Spec lines are indented with 4 spaces: "    gem-name (version)"
+      SPEC_LINE = /\A {4}(\S+)\s/
+
+      attr_reader :path
+
+      # Creates a parser for extracting gem names from a Gemfile.lock
+      # @param path [Pathname] the path to the Gemfile.lock file
+      #
+      # @return [GemfileLock]
+      def initialize(path)
+        @path = path
+      end
+
+      # Returns the set of gem names found in the specs section
+      #
+      # @return [Set<String>] gem names
+      def gem_names
+        return Set.new unless path.exist?
+
+        parse_specs
+      end
+
+      private
+
+      def parse_specs
+        in_specs = false
+        gems = Set.new
+
+        path.each_line do |line|
+          in_specs, gem_name = process_line(line, in_specs)
+          gems.add(gem_name) if gem_name
+        end
+
+        gems
+      end
+
+      def process_line(line, in_specs)
+        return [true, nil] if line.strip == 'specs:'
+        return [in_specs, nil] unless in_specs
+
+        match = line.match(SPEC_LINE)
+        return [true, match[1]] if match
+
+        still_in_specs = line.start_with?('      ') || line.strip.empty?
+        [still_in_specs, nil]
+      end
+    end
+  end
+end

data/lib/reviewer/setup/generator.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+require_relative 'tool_block'
+
+module Reviewer
+  module Setup
+    # Produces .reviewer.yml YAML content from a list of detected tool keys.
+    # Orchestrates which tools to include; delegates per-tool rendering to ToolBlock.
+    class Generator
+      attr_reader :tool_keys, :project_dir
+
+      # Creates a generator for producing .reviewer.yml configuration
+      # @param tool_keys [Array<Symbol>] catalog tool keys to include in config
+      # @param project_dir [Pathname] the project root (used for package manager detection)
+      #
+      # @return [Generator]
+      def initialize(tool_keys, project_dir: Pathname.pwd)
+        @tool_keys = tool_keys
+        @project_dir = Pathname(project_dir)
+      end
+
+      # Generates YAML configuration string for the detected tools
+      #
+      # @return [String] valid YAML for .reviewer.yml
+      def generate
+        return "--- {}\n" if tool_keys.empty?
+
+        blocks = tool_keys.filter_map do |key|
+          definition = Catalog.config_for(key)
+          next unless definition
+
+          ToolBlock.new(key, definition, js_runner: js_runner).to_s
+        end
+
+        "---\n#{blocks.join("\n")}"
+      end
+
+      private
+
+      # Detects the JS package manager based on lockfile presence
+      def js_runner
+        @js_runner ||= if project_dir.join('yarn.lock').exist?
+                         'yarn'
+                       elsif project_dir.join('pnpm-lock.yaml').exist?
+                         'pnpm exec'
+                       else
+                         'npx'
+                       end
+      end
+    end
+  end
+end

data/lib/reviewer/setup/tool_block.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Reviewer
+  module Setup
+    # Renders the YAML configuration block for a single tool definition.
+    # Owns the definition data so rendering methods reference self's state
+    # rather than reaching into parameters.
+    class ToolBlock
+      YAML_BARE_WORDS = %w[true false yes no on off null ~].freeze
+
+      # Creates a renderer for a single tool's YAML configuration block
+      # @param key [Symbol] the tool key (e.g., :rubocop)
+      # @param definition [Hash] the catalog definition for this tool
+      # @param js_runner [String] the JS package runner to substitute for npx
+      #
+      # @return [ToolBlock]
+      def initialize(key, definition, js_runner:)
+        @key = key
+        @definition = definition
+        @js_runner = js_runner
+      end
+
+      # Renders the full YAML block for this tool
+      #
+      # @return [String] the YAML text for this tool's configuration
+      def to_s
+        lines = header_lines
+        lines.concat(commands_block)
+        lines.concat(files_block) if @definition[:files]
+        lines << ''
+        lines.join("\n")
+      end
+
+      private
+
+      def header_lines
+        lines = []
+        lines << "# #{@definition[:description]}"
+        lines << "#{@key}:"
+        lines << "  name: #{quote(@definition[:name])}"
+        lines << "  description: #{quote(@definition[:description])}"
+        lines << tags_line if @definition[:tags]&.any?
+        lines
+      end
+
+      def tags_line
+        "  tags: [#{@definition[:tags].join(', ')}]"
+      end
+
+      def commands_block
+        commands = @definition[:commands]
+        lines = ['  commands:']
+        %i[install prepare review format].each do |type|
+          next unless commands[type]
+
+          lines << "    #{type}: #{quote(apply_js_runner(commands[type].to_s))}"
+        end
+        lines
+      end
+
+      def files_block
+        lines = ['  files:']
+        lines.concat(files_command_lines)
+        lines.concat(files_targeting_lines)
+        lines
+      end
+
+      def files_command_lines
+        %i[review format].filter_map do |type|
+          "    #{type}: #{quote(apply_js_runner(tool_files[type].to_s))}" if tool_files[type]
+        end
+      end
+
+      def files_targeting_lines
+        [
+          (file_setting_line(:flag) if tool_files.key?(:flag)),
+          (file_setting_line(:separator) if tool_files.key?(:separator)),
+          (file_setting_line(:pattern) if tool_files[:pattern]),
+          ("    map_to_tests: #{tool_files[:map_to_tests]}" if tool_files[:map_to_tests])
+        ].compact
+      end
+
+      def file_setting_line(key)
+        "    #{key}: #{quote(tool_files[key])}"
+      end
+
+      def tool_files
+        @definition[:files]
+      end
+
+      def apply_js_runner(command)
+        return command unless command.start_with?('npx ')
+
+        command.sub('npx ', "#{@js_runner} ")
+      end
+
+      def quote(value)
+        str = value.to_s
+        return "''" if str.empty?
+
+        needs_quoting?(str) ? "'#{str.gsub("'", "''")}'" : str
+      end
+
+      def needs_quoting?(str)
+        str.match?(/[:#\[\]{}&*!|>'"@`,]/) ||
+          str.strip != str ||
+          str.empty? ||
+          YAML_BARE_WORDS.include?(str.downcase)
+      end
+    end
+  end
+end

data/lib/reviewer/setup.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'setup/catalog'
+require_relative 'setup/detector'
+require_relative 'setup/formatter'
+require_relative 'setup/gemfile_lock'
+require_relative 'setup/generator'
+
+module Reviewer
+  # Handles first-run setup: detecting tools and generating .reviewer.yml
+  module Setup
+    # URL to the configuration documentation for setup output messages
+    CONFIG_URL = 'https://github.com/garrettdimon/reviewer#configuration'
+
+    # Runs the full setup flow: detect tools, generate config, display results
+    # @param project_dir [Pathname, String] the project root to scan (defaults to pwd)
+    # @param output [Output] the console output handler
+    #
+    # @return [void]
+    def self.run(configuration:, project_dir: Pathname.pwd, output: Output.new)
+      config_file = configuration.file
+      formatter = Formatter.new(output)
+
+      if config_file.exist?
+        formatter.setup_already_exists(config_file)
+        return
+      end
+
+      results = Detector.new(project_dir).detect
+
+      if results.empty?
+        formatter.setup_no_tools_detected
+        return
+      end
+
+      yaml = Generator.new(results.map(&:key), project_dir: project_dir).generate
+      config_file.write(yaml)
+      formatter.setup_success(results)
+    end
+  end
+end