exercism-rb 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e3f086e7d56d3ef1314ac284fd277f39a34b6fba990e3979a20bb1a0a956673
-  data.tar.gz: 7258ab70a894221f104f6acb044fdae965d6dcd73af1070e45e829e48e780931
+  metadata.gz: 52de31694fce53072b7cff336f8b31ee600c90dc10f847b2b73ff4b22616fc6b
+  data.tar.gz: 17c72ff5d2eea013d0e7edc0f8ac5a82533e5777ed9d555e8d35d10cfff45221
 SHA512:
-  metadata.gz: 5ea881fb4335c63357ca7cbe2741c3ecda1d1c12a81363bb2d1354f35db9d6b7cea49fc098da57ccfbb659b164774b52214cbef972b97e80704baa8bb90df0ee
-  data.tar.gz: 3537495bab0755c3521642d6014edd7a2f2ae633f8366f700f852bfc89d631495aaf56e3a0f12e874324db0de110c634be4020a86aca3c4dac5f72531d07109b
+  metadata.gz: 9372500b14d3b8e09a4e8bc48e54a19afb6a4eae9cd91730c70bd92974d78ab57db6c51d51bbff0a450e99e65684d7bdeb64914dc98085fb4174f05e1587dda9
+  data.tar.gz: 646c0ceebb0d862635cb4c17f10ba8aa9134437c5e512e3c9dc6e58f95d03aec96c38834b1d2eb9444c3c9d8e7e229967784d783ea491005ca0814f572af326b

data/CHANGELOG.md

@@ -7,6 +7,32 @@ and this project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.ht
 
 ## Unreleased
 
+## 0.2.0 - 2026-05-06
+
+### Added
+
+- Support for `.exercism/config.json` `files.solution` and `files.test` metadata.
+- `--no-edit` for `xrb new` to download and save the current exercise without opening an editor.
+- Repeatable `--file FILE` overrides for `xrb submit` and `xrb test`.
+- Standard, Bundler Audit, Reek, RubyCritic, and opt-in SimpleCov coverage as development quality tools.
+
+### Changed
+
+- `xrb submit` now delegates default file selection to the Exercism CLI when exercise config is available.
+- `xrb test` can run multiple configured or explicitly selected test files in order.
+- `xrb edit` and `xrb new` now require an explicit editor through `XRB_EDITOR`, `VISUAL`, or `EDITOR` instead of assuming `nvim`.
+- CLI status, warning, and error output now uses color without log-style labels.
+- Release process details moved from `README.md` to `CONTRIBUTING.md`.
+
+### Removed
+
+- Removed the legacy source installer; RubyGems is now the only supported installation path.
+
+### Fixed
+
+- `xrb new` now explains the likely workspace mismatch when download succeeds but the expected exercise directory is missing.
+- Command execution errors now distinguish missing commands from commands that ran and returned a non-zero exit code.
+
 ## 0.1.0 - 2026-05-06
 
 ### Added

data/README.md

@@ -1,5 +1,10 @@
 # exercism-rb
 
+[![Gem Version](https://badge.fury.io/rb/exercism-rb.svg)](https://rubygems.org/gems/exercism-rb)
+[![CI](https://github.com/hvpaiva/exercism-rb/actions/workflows/ci.yml/badge.svg)](https://github.com/hvpaiva/exercism-rb/actions/workflows/ci.yml)
+[![License](https://img.shields.io/github/license/hvpaiva/exercism-rb)](LICENSE)
+[![Downloads](https://img.shields.io/gem/dt/exercism-rb)](https://rubygems.org/gems/exercism-rb)
+
 `xrb` is a small CLI that removes friction from the Exercism Ruby workflow.
 
 It remembers the current exercise, runs commands from the right exercise directory, opens your editor, starts IRB with the solution file loaded, runs tests, and submits the solution file without requiring manual `cd` work.
@@ -30,7 +35,7 @@ gem update exercism-rb
 
 - Ruby 3.2+
 - Exercism CLI for `xrb new` and `xrb submit`
-- An editor available on `PATH`
+- An editor available on `PATH` and configured through `XRB_EDITOR`, `VISUAL`, or `EDITOR` for `xrb edit` and default `xrb new`
 
 Configure the Exercism CLI separately:
 
@@ -53,9 +58,9 @@ xrb submit
 ```bash
 xrb new <exercise>       # download, save as current, and open the editor
 xrb edit [exercise]      # open the editor for an exercise
-xrb test [exercise]      # run the exercise test file with minitest/pride
+xrb test [exercise]      # run configured or selected test files
 xrb irb [exercise]       # open irb -r ./<solution>.rb --simple-prompt
-xrb submit [exercise]    # submit the solution .rb file
+xrb submit [exercise]    # submit through the Exercism CLI
 xrb use <exercise>       # save a downloaded exercise as current
 xrb current              # show the current exercise
 xrb path [exercise]      # print the exercise path
@@ -69,7 +74,18 @@ Exercise resolution priority:
 2. Current working directory when inside `XRB_ROOT`
 3. Saved state from the previous `xrb new` or `xrb use`
 
-`xrb test` expects a single `*_test.rb` file in the exercise directory and reports an ambiguity if more than one is present.
+`xrb test` reads `.exercism/config.json` when available and runs each file listed in `files.test`. Without that config, it preserves the older fallback of requiring a single `*_test.rb` file.
+
+`xrb submit` lets the Exercism CLI choose default solution files when `.exercism/config.json` is present. Without that config, it preserves the older fallback of requiring a single solution `.rb` file.
+
+Both `xrb test` and `xrb submit` accept a repeatable explicit override:
+
+```bash
+xrb test --file custom_test.rb
+xrb submit two-fer --file two_fer.rb --file helper.rb
+```
+
+Use `xrb new <exercise> --no-edit` to download and save the exercise as current without opening an editor.
 
 ## Output And Color
 
@@ -109,53 +125,19 @@ updated_at = "2026-05-05T12:00:00Z"
 ```bash
 XRB_ROOT=~/exercism/ruby      # exercise directory
 XRB_TRACK=ruby                # Exercism track
-XRB_EDITOR=nvim               # editor used by xrb new/edit
+XRB_EDITOR="code --wait"      # editor used by xrb new/edit
 XRB_STATE=~/.local/state/exercism-rb/state.toml
 XRB_COLOR=auto                # auto, always, or never
 ```
 
 `xrb new` uses `exercism download`, which downloads into the workspace configured in the Exercism CLI. If you customize `XRB_ROOT`, configure the Exercism workspace so its track directory matches it, for example `exercism configure --workspace ~/exercism` for `XRB_ROOT=~/exercism/ruby`.
 
-Editor commands are split with shell-like quoting, so this works:
+Set `XRB_EDITOR`, `VISUAL`, or `EDITOR` before running `xrb edit` or `xrb new` without `--no-edit`. Editor commands are split with shell-like quoting, so this works:
 
 ```bash
 XRB_EDITOR="code --wait" xrb edit
 ```
 
-## Source Installer
-
-RubyGems is the recommended installation path. The repository also keeps a source installer for users who want to install directly from `main`:
-
-```bash
-curl -fsSL https://raw.githubusercontent.com/hvpaiva/exercism-rb/main/install.rb | ruby
-```
-
-The installer clones or updates the repository at `~/.local/share/exercism-rb` and creates this symlink:
-
-```text
-~/.local/bin/xrb -> ~/.local/share/exercism-rb/bin/xrb
-```
-
-It also installs the Exercism CLI into `~/.local/bin/exercism` when `exercism` is not already available.
-
-To skip the Exercism CLI install:
-
-```bash
-curl -fsSL https://raw.githubusercontent.com/hvpaiva/exercism-rb/main/install.rb | ruby - --no-exercism
-```
-
-To force-install or update the Exercism CLI:
-
-```bash
-curl -fsSL https://raw.githubusercontent.com/hvpaiva/exercism-rb/main/install.rb | ruby - --with-exercism
-```
-
-If `~/.local/bin/xrb` is an existing symlink, the installer replaces the symlink without deleting the old target. If it is a real file or directory, the installer refuses to replace it unless you opt in:
-
-```bash
-curl -fsSL https://raw.githubusercontent.com/hvpaiva/exercism-rb/main/install.rb | XRB_INSTALL_OVERWRITE=1 ruby
-```
-
 ## Development
 
 Install development dependencies:
@@ -176,7 +158,7 @@ Run the full verification suite:
 bundle exec rake ci
 ```
 
-The CI task checks syntax, runs tests, runs tests with Ruby warnings enabled, smoke-tests the checkout executable, builds the gem, installs it into an isolated `GEM_HOME`, and smoke-tests the installed `xrb` executable.
+The CI task checks syntax, runs tests, runs tests with Ruby warnings enabled, runs required quality checks, smoke-tests the checkout executable, builds the gem, installs it into an isolated `GEM_HOME`, and smoke-tests the installed `xrb` executable.
 
 Useful individual tasks:
 
@@ -184,29 +166,23 @@ Useful individual tasks:
 bundle exec rake test
 bundle exec rake syntax
 bundle exec rake warnings
+bundle exec rake style
+bundle exec rake audit
+bundle exec rake quality
+bundle exec rake coverage
 bundle exec rake smoke:bin
 bundle exec rake smoke:gem
 ```
 
-## Release
-
-Publishing is automated through RubyGems Trusted Publishing and GitHub Actions. No long-lived `RUBYGEMS_AUTH_TOKEN` is required for the recommended release path.
+Optional maintenance reports:
 
-Before the first release, configure a pending trusted publisher on RubyGems.org:
-
-```text
-Gem name: exercism-rb
-GitHub repository: hvpaiva/exercism-rb
-Workflow filename: release.yml
-Environment: release
+```bash
+bundle exec rake smells
+bundle exec rake critic
 ```
 
-Release checklist:
+`bundle exec rake critic` writes its report to `tmp/rubycritic/`, which is ignored by Git.
 
-1. Update `lib/exercism/rb/version.rb`
-2. Update `CHANGELOG.md`
-3. Run `bundle exec rake ci`
-4. Commit the release changes
-5. Create and push a tag that matches the version, for example `v0.1.0` for `VERSION = "0.1.0"`
+## Release
 
-The `Release` workflow runs only for `v*` tags. It verifies the project and publishes the gem through `rubygems/release-gem@v1`.
+Release process details are maintainer documentation and live in `CONTRIBUTING.md`.

data/lib/exercism/rb/cli.rb

@@ -6,6 +6,24 @@ module Exercism
   module Rb
     class CLI
       COMMANDS = %w[new edit test irb submit use current path list clear help version].freeze
+      COMMAND_METHODS = {
+        "new" => :new_command,
+        "edit" => :edit_command,
+        "test" => :test_command,
+        "irb" => :irb_command,
+        "submit" => :submit_command,
+        "use" => :use_command,
+        "current" => :current_command,
+        "path" => :path_command,
+        "list" => :list_command,
+        "clear" => :clear_command,
+        "help" => :help_command,
+        "-h" => :help_command,
+        "--help" => :help_command,
+        "version" => :version_command,
+        "-v" => :version_command,
+        "--version" => :version_command
+      }.freeze
 
       def self.start(argv, out: $stdout, err: $stderr)
         new(argv, out: out, err: err).start
@@ -23,27 +41,13 @@ module Exercism
 
       def start
         command = @argv.shift || "help"
+        handler = COMMAND_METHODS.fetch(command) { raise Error, "Unknown command: #{command}. Use `xrb help`." }
 
-        case command
-        when "new" then new_command
-        when "edit" then edit_command
-        when "test" then test_command
-        when "irb" then irb_command
-        when "submit" then submit_command
-        when "use" then use_command
-        when "current" then current_command
-        when "path" then path_command
-        when "list" then list_command
-        when "clear" then clear_command
-        when "help", "-h", "--help" then help_command
-        when "version", "-v", "--version" then version_command
-        else
-          raise Error, "Unknown command: #{command}. Use `xrb help`."
-        end
+        __send__(handler)
 
         0
-      rescue Error => e
-        @ui.error(e.message)
+      rescue Error => error
+        @ui.error(error.message)
         1
       rescue Interrupt
         @ui.error("Interrupted.")
@@ -53,14 +57,15 @@ module Exercism
       private
 
       def new_command
+        skip_editor = extract_no_edit_option!
         exercise = exercise_from_required_arg("new <exercise>", require_existing: false)
 
         @ui.info("Downloading #{@ui.highlight(exercise.slug)}...")
         @runner.run("exercism", "download", "--track=#{exercise.track}", "--exercise=#{exercise.slug}")
-        exercise.ensure_exists!
+        ensure_download_created_exercise!(exercise)
         save_current(exercise)
         @ui.key_value("Path", @ui.path(exercise.path))
-        edit_exercise(exercise)
+        edit_exercise(exercise) unless skip_editor
       end
 
       def edit_command
@@ -68,11 +73,15 @@ module Exercism
       end
 
       def test_command
+        files = extract_file_options!
         exercise = @resolver.resolve(optional_arg)
-        test_file = exercise.test_file
+        test_files = files.empty? ? exercise.test_files(ambiguity_hint: "Use --file FILE to choose test files explicitly.") : files
+        ensure_test_files_exist!(exercise, test_files)
 
         @ui.info("Testing #{@ui.highlight(exercise.slug)}...")
-        @runner.run("ruby", "-r", "minitest/pride", test_file, chdir: exercise.path)
+        test_files.each do |test_file|
+          @runner.run("ruby", "-r", "minitest/pride", test_file, chdir: exercise.path)
+        end
       end
 
       def irb_command
@@ -84,11 +93,16 @@ module Exercism
       end
 
       def submit_command
+        files = extract_file_options!
         exercise = @resolver.resolve(optional_arg)
-        solution_file = exercise.solution_file
 
         @ui.info("Submitting #{@ui.highlight(exercise.slug)}...")
-        @runner.run("exercism", "submit", solution_file, chdir: exercise.path)
+        if files.empty? && exercise.exercism_config?
+          @runner.run("exercism", "submit", chdir: exercise.path)
+        else
+          files = [exercise.solution_file(ambiguity_hint: "Use --file FILE to choose files explicitly.")] if files.empty?
+          @runner.run("exercism", "submit", *files, chdir: exercise.path)
+        end
       end
 
       def use_command
@@ -121,8 +135,8 @@ module Exercism
 
         current = @state.load["exercise"]
         exercises = Dir.children(@root)
-                       .select { |name| File.directory?(File.join(@root, name)) && !name.start_with?(".") }
-                       .sort
+          .select { |name| File.directory?(File.join(@root, name)) && !name.start_with?(".") }
+          .sort
 
         if exercises.empty?
           @ui.warn("No exercises downloaded in #{@root}.")
@@ -131,9 +145,9 @@ module Exercism
 
         @ui.section("Downloaded exercises")
         exercises.each do |slug|
-          marker = slug == current ? "*" : " "
-          label = slug == current ? @ui.highlight(slug) : slug
-          suffix = slug == current ? " #{@ui.muted('current')}" : ""
+          marker = (slug == current) ? "*" : " "
+          label = (slug == current) ? @ui.highlight(slug) : slug
+          suffix = (slug == current) ? " #{@ui.muted("current")}" : ""
           @ui.say("#{marker} #{label}#{suffix}")
         end
       end
@@ -145,27 +159,31 @@ module Exercism
 
       def help_command
         @ui.say(<<~HELP)
-          #{@ui.bold('xrb')} - Exercism Ruby helper
+          #{@ui.bold("xrb")} - Exercism Ruby helper
 
           Usage:
             xrb new <exercise>       download, save as current, and open the editor
             xrb edit [exercise]      open the editor for an exercise
-            xrb test [exercise]      run the exercise test file with minitest/pride
+            xrb test [exercise]      run exercise tests with minitest/pride
             xrb irb [exercise]       open irb -r ./<solution>.rb --simple-prompt
-            xrb submit [exercise]    submit the solution .rb file
+            xrb submit [exercise]    submit the exercise solution
             xrb use <exercise>       save a downloaded exercise as current
             xrb current              show the current exercise
             xrb path [exercise]      print the exercise path
             xrb list                 list downloaded exercises
             xrb clear                clear saved state
 
+          Options:
+            --no-edit               skip opening the editor after xrb new
+            --file FILE              test or submit an explicit file; may be repeated
+
           State:
             #{@state.path}
 
           Environment:
             XRB_ROOT     exercise directory (current: #{@root})
             XRB_TRACK    Exercism track (current: #{@track})
-            XRB_EDITOR   editor used by xrb edit/new (default: nvim)
+            XRB_EDITOR   editor used by xrb edit/new
             XRB_STATE    TOML state file
             XRB_COLOR    color output: auto, always, or never
         HELP
@@ -185,10 +203,82 @@ module Exercism
         @runner.run(*editor_args, target, chdir: exercise.path)
       end
 
+      def ensure_download_created_exercise!(exercise)
+        return if exercise.exists?
+
+        raise Error, <<~MESSAGE.chomp
+          Download completed, but xrb could not find the expected exercise directory:
+          #{exercise.path}
+
+          The Exercism CLI probably downloaded to another workspace. Configure it to match XRB_ROOT:
+          exercism configure --workspace #{File.dirname(@root)}
+        MESSAGE
+      end
+
+      def ensure_test_files_exist!(exercise, test_files)
+        test_files.each do |file|
+          next if File.file?(File.absolute_path(file, exercise.path))
+
+          raise Error, "Test file not found: #{file}"
+        end
+      end
+
+      def extract_file_options!
+        files = []
+        remaining = []
+
+        until @argv.empty?
+          arg = @argv.shift
+
+          case arg
+          when "--file"
+            value = @argv.shift
+            raise Error, "Missing value for --file" if blank?(value)
+
+            files << value
+          when /\A--file=(.*)\z/
+            value = Regexp.last_match(1)
+            raise Error, "Missing value for --file" if blank?(value)
+
+            files << value
+          else
+            raise Error, "Unknown option: #{arg}" if arg.start_with?("-")
+
+            remaining << arg
+          end
+        end
+
+        @argv = remaining
+        files
+      end
+
+      def extract_no_edit_option!
+        skip_editor = false
+        remaining = []
+
+        until @argv.empty?
+          arg = @argv.shift
+
+          if arg == "--no-edit"
+            skip_editor = true
+          else
+            raise Error, "Unknown option: #{arg}" if arg.start_with?("-")
+
+            remaining << arg
+          end
+        end
+
+        @argv = remaining
+        skip_editor
+      end
+
       def editor_args_from_config
-        Shellwords.split(Config.editor)
-      rescue ArgumentError => e
-        raise Error, "Invalid editor in XRB_EDITOR/VISUAL/EDITOR: #{e.message}"
+        editor = Config.editor
+        raise Error, "No editor configured. Set XRB_EDITOR, VISUAL, or EDITOR." if blank?(editor)
+
+        Shellwords.split(editor)
+      rescue ArgumentError => error
+        raise Error, "Invalid editor in XRB_EDITOR/VISUAL/EDITOR: #{error.message}"
       end
 
       def ensure_editor_available!(command, chdir:)
@@ -229,7 +319,7 @@ module Exercism
       def exercise_from_required_arg(usage, require_existing: true)
         slug = @argv.shift
         raise Error, "Usage: xrb #{usage}" if blank?(slug)
-        raise Error, "Too many arguments: #{@argv.join(' ')}" unless @argv.empty?
+        raise Error, "Too many arguments: #{@argv.join(" ")}" unless @argv.empty?
 
         Exercise.new(slug: slug, track: @track, root: @root).tap do |exercise|
           exercise.ensure_exists! if require_existing
@@ -238,7 +328,7 @@ module Exercism
 
       def optional_arg
         slug = @argv.shift
-        raise Error, "Too many arguments: #{@argv.join(' ')}" unless @argv.empty?
+        raise Error, "Too many arguments: #{@argv.join(" ")}" unless @argv.empty?
 
         slug
       end

data/lib/exercism/rb/command_runner.rb

@@ -15,12 +15,19 @@ module Exercism
         @ui.command("$ #{printable}")
 
         ok = if chdir
-               Dir.chdir(chdir) { system(*args) }
-             else
-               system(*args)
-             end
+          Dir.chdir(chdir) { system(*args) }
+        else
+          system(*args)
+        end
 
-        raise Error, "Command failed: #{Shellwords.join(args)}" unless ok
+        case ok
+        when true
+          true
+        when nil
+          raise Error, "Command not found: #{args.first}. Install it or ensure it is on PATH."
+        else
+          raise Error, "Command failed: #{Shellwords.join(args)}"
+        end
 
         true
       end

data/lib/exercism/rb/config.rb

@@ -18,7 +18,7 @@ module Exercism
       end
 
       def editor
-        ENV["XRB_EDITOR"] || ENV["VISUAL"] || ENV["EDITOR"] || "nvim"
+        ENV["XRB_EDITOR"] || ENV["VISUAL"] || ENV["EDITOR"]
       end
     end
   end

data/lib/exercism/rb/exercise.rb

@@ -1,9 +1,15 @@
 # frozen_string_literal: true
 
+require "json"
+
 module Exercism
   module Rb
     class Exercise
       SLUG_PATTERN = /\A[a-z0-9][a-z0-9-]*\z/
+      FILE_KINDS = {
+        "test" => {config: "test file", fallback: "test file (*_test.rb)"},
+        "solution" => {config: "solution file", fallback: "solution file (.rb)"}
+      }.freeze
 
       attr_reader :slug, :track, :root, :path
 
@@ -16,6 +22,7 @@ module Exercism
         @track = track
         @root = File.expand_path(root)
         @path = File.expand_path(path || File.join(@root, @slug))
+        @exercism_config = nil
       end
 
       def exists?
@@ -28,32 +35,124 @@ module Exercism
         raise Error, "Exercise not found: #{@path}"
       end
 
-      def test_file
-        ensure_exists!
-        pick_one(files_matching { |name| name.end_with?("_test.rb") }, kind: "test file (*_test.rb)")
+      def exercism_config?
+        File.file?(config_path)
       end
 
-      def solution_file
-        ensure_exists!
-        pick_one(files_matching { |name| name.end_with?(".rb") && !name.end_with?("_test.rb") }, kind: "solution file (.rb)")
+      def test_files(ambiguity_hint: nil)
+        exercise_files("test", ambiguity_hint: ambiguity_hint) do
+          fallback_test_files
+        end
+      end
+
+      def solution_files(ambiguity_hint: nil)
+        exercise_files("solution", ambiguity_hint: ambiguity_hint) do
+          fallback_solution_files
+        end
+      end
+
+      def test_file(ambiguity_hint: nil)
+        pick_one(test_files(ambiguity_hint: ambiguity_hint), kind: "test file (*_test.rb)", ambiguity_hint: ambiguity_hint)
+      end
+
+      def solution_file(ambiguity_hint: nil)
+        pick_one(solution_files(ambiguity_hint: ambiguity_hint), kind: "solution file (.rb)", ambiguity_hint: ambiguity_hint)
       end
 
       private
 
+      def config_path
+        File.join(@path, ".exercism", "config.json")
+      end
+
+      def exercise_files(config_name, ambiguity_hint:)
+        ensure_exists!
+
+        kinds = FILE_KINDS.fetch(config_name)
+        configured_files(config_name, kind: kinds.fetch(:config)) || [pick_one(yield, kind: kinds.fetch(:fallback), ambiguity_hint: ambiguity_hint)]
+      end
+
+      def exercism_config
+        return nil unless exercism_config?
+        return @exercism_config unless @exercism_config.nil?
+
+        config = JSON.parse(File.read(config_path))
+        raise_invalid_config("root must be an object") unless config.is_a?(Hash)
+
+        @exercism_config = config
+      rescue JSON::ParserError => error
+        raise Error, "Invalid Exercism config: #{config_path}: #{error.message}"
+      end
+
+      def configured_files(name, kind:)
+        config = exercism_config
+        return nil if config.nil?
+
+        values = configured_file_values(config, name)
+        return nil if values.nil?
+
+        ensure_configured_files_exist(values, kind: kind)
+      end
+
+      def configured_file_values(config, name)
+        files = config.fetch("files", nil)
+        return nil if files.nil?
+        raise_invalid_config("files must be an object") unless files.is_a?(Hash)
+        return nil unless files.key?(name)
+
+        values = files.fetch(name)
+        validate_configured_file_list(name, values)
+      end
+
+      def validate_configured_file_list(name, values)
+        raise_invalid_config("files.#{name} must be an array") unless values.is_a?(Array)
+        raise_invalid_config("files.#{name} must not be empty") if values.empty?
+
+        values.each do |file|
+          raise_invalid_config("files.#{name} contains an empty path") unless file.is_a?(String) && !file.strip.empty?
+        end
+
+        values
+      end
+
+      def ensure_configured_files_exist(files, kind:)
+        files.each do |file|
+          next if File.file?(File.absolute_path(file, @path))
+
+          raise Error, "Configured #{kind} not found: #{file}"
+        end
+
+        files
+      end
+
+      def raise_invalid_config(message)
+        raise Error, "Invalid Exercism config: #{config_path}: #{message}"
+      end
+
+      def fallback_test_files
+        files_matching { |name| name.end_with?("_test.rb") }
+      end
+
+      def fallback_solution_files
+        files_matching { |name| name.end_with?(".rb") && !name.end_with?("_test.rb") }
+      end
+
       def files_matching
         Dir.children(@path)
-           .select { |name| File.file?(File.join(@path, name)) && yield(name) }
-           .sort
+          .select { |name| File.file?(File.join(@path, name)) && yield(name) }
+          .sort
       end
 
-      def pick_one(files, kind:)
+      def pick_one(files, kind:, ambiguity_hint: nil)
         case files.length
         when 0
           raise Error, "Could not find #{kind} in #{@path}"
         when 1
           files.first
         else
-          raise Error, "Found more than one #{kind} in #{@path}: #{files.join(', ')}"
+          message = "Found more than one #{kind} in #{@path}: #{files.join(", ")}"
+          message = "#{message}. #{ambiguity_hint}" if ambiguity_hint
+          raise Error, message
         end
       end
     end

data/lib/exercism/rb/resolver.rb

@@ -11,10 +11,10 @@ module Exercism
 
       def resolve(slug = nil, require_existing: true)
         exercise = if present?(slug)
-                     Exercise.new(slug: slug, track: @track, root: @root)
-                   else
-                     from_current_directory || from_state
-                   end
+          Exercise.new(slug: slug, track: @track, root: @root)
+        else
+          from_current_directory || from_state
+        end
 
         exercise.ensure_exists! if require_existing
         exercise

data/lib/exercism/rb/state.rb

@@ -93,11 +93,11 @@ module Exercism
 
       def quote(value)
         escaped = value.to_s
-                       .gsub("\\", "\\\\")
-                       .gsub('"', '\\"')
-                       .gsub("\n", "\\n")
-                       .gsub("\r", "\\r")
-                       .gsub("\t", "\\t")
+          .gsub("\\", "\\\\")
+          .gsub('"', '\\"')
+          .gsub("\n", "\\n")
+          .gsub("\r", "\\r")
+          .gsub("\t", "\\t")
 
         %("#{escaped}")
       end

data/lib/exercism/rb/ui.rb

@@ -50,19 +50,19 @@ module Exercism
       end
 
       def info(message)
-        @out.puts("#{paint('info', :blue)} #{message}")
+        @out.puts(paint(message, :blue))
       end
 
       def success(message)
-        @out.puts("#{paint('done', :green)} #{message}")
+        @out.puts(paint(message, :green))
       end
 
       def warn(message)
-        @err.puts("#{paint('warn', :yellow)} #{message}")
+        @err.puts(paint(message, :yellow))
       end
 
       def error(message)
-        @err.puts("#{paint('error', :red)} #{message}")
+        @err.puts(paint(message, :red))
       end
 
       def command(message)

data/lib/exercism/rb/version.rb

@@ -2,6 +2,6 @@
 
 module Exercism
   module Rb
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: exercism-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - hvpaiva
@@ -10,6 +10,20 @@ bindir: bin
 cert_chain: []
 date: 2026-05-06 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler-audit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -38,6 +52,62 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.2'
+- !ruby/object:Gem::Dependency
+  name: reek
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubycritic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.40'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.40'
 description: A small command-line helper that keeps Exercism Ruby exercises easy to
   open, test, inspect, and submit.
 email: