quick_check 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 896e5b8930fe9d6f9c090ef32c1bbc70a57a05d415c7ad6996e5a4e211868963
+  data.tar.gz: ae0e8f1831e674357081df078d68cfdbf3966c22d09f6c826becaa7d6a21bd90
+SHA512:
+  metadata.gz: cddc454b92ad6e3c2c1f9afe08dab40305c9ee29bfe91d35a44fe578b7c52bb27cc09dbd1806c13d6cb9350bb4e945a0e2e1c24c757bbb005865739b2cd9281f
+  data.tar.gz: 7952bbeb5140d87b51b189b464ee7309367a49fc687e099bdcd124b9d5744b0914735d0336b36d500a6dbe781b2bae5101101519a9446af319f2bbb442256fc4

data/.rspec

@@ -0,0 +1,2 @@
+--require spec_helper
+--format documentation

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Kasvit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,126 @@
+# quick_check
+
+Run only the tests that changed (RSpec or Minitest). Fast.
+
+`quick_check` installs a `qc` command that finds changed/added test files (staged, unstaged, and untracked by default) and runs them using the appropriate test runner automatically.
+
+## Basic Usage
+
+Install the gem and run `qc` to run the tests that changed.
+
+```bash
+gem install quick_check
+qc
+```
+
+## Features
+
+- Detects changed test files under:
+  - RSpec: `spec/**/*_spec.rb`
+  - Minitest: `test/**/*_test.rb`
+  - Also maps changed source files to their tests:
+    - `app/models/user.rb` -> `spec/models/user_spec.rb` / `test/models/user_test.rb`
+    - `app/controllers/home_controller.rb` -> `spec/requests/home_spec.rb` or `spec/requests/home_controller_spec.rb` (fallbacks), and controller tests as fallback; similarly for Minitest under `test/integration` and `test/controllers`
+    - `lib/foo/bar.rb` -> `spec/lib/foo/bar_spec.rb` / `test/lib/foo/bar_test.rb`
+- Includes (by default):
+  - Unstaged working tree changes
+  - Staged (index) changes
+  - Untracked files (new specs not yet added)
+  - All committed changes on your branch vs base (`main`/`master`)
+- You can disable branch commits with `--no-committed`
+- Auto-detects base branch (`main` or `master`) or configure via `.quick_check.yml`
+- Auto-detects framework and command:
+  - RSpec: `bundle exec rspec <files>`
+  - Rails + Minitest: `bin/rails test <files>` (or `bundle exec rails test <files>`)
+  - Plain Minitest: per-file `ruby -I test <file>`
+- Always prints the full command(s) before executing
+- `--cmd` to override the command for advanced use-cases
+
+## Install
+
+From source:
+
+```bash
+gem install quick_check
+```
+
+Once installed, the `qc` executable will be available in your shell.
+
+## Usage
+
+```bash
+# Run all changed tests in your branch (default: committed + staged + unstaged + untracked)
+qc
+
+# Print matching spec file paths only (no execution)
+qc --print
+
+# Dry-run: print the exact command that would run
+qc --dry-run
+
+# Only current edits (ignore previously committed changes in this branch)
+qc --no-committed
+
+# Specify/override the base branch
+qc --base main
+
+# Only committed changes vs base (ignore working tree)
+qc --no-staged --no-unstaged
+
+# Use a custom test command
+qc --cmd "bundle exec rspec --fail-fast"
+
+# Verbose output
+qc --verbose
+```
+
+## Options
+
+- `--base BRANCH`: Base branch to diff against (overrides config)
+- `--committed` / `--no-committed`: Include or exclude committed changes vs base (default: include)
+- `--no-staged`: Ignore staged changes
+- `--no-unstaged`: Ignore unstaged changes
+- `--cmd CMD`: Override test command (default: auto-detected runner)
+- `-p`, `--print`: Only print matched files, do not run
+- `-n`, `--dry-run`: Print the command that would run and exit
+- `-v`, `--verbose`: Verbose/debug output
+- `-h`, `--help`: Show help
+
+## Configuration
+
+Create `.quick_check.yml` in the repo root (or current directory) to set defaults:
+
+```yml
+# .quick_check.yml
+base_branch: main
+```
+
+If no config is present, `qc` will use the first existing branch among `main` or `master`.
+
+## How it works
+
+- Unstaged: `git diff --name-only --diff-filter=ACMR`
+- Staged: `git diff --name-only --cached --diff-filter=ACMR`
+- Untracked: `git ls-files --others --exclude-standard`
+- Committed vs base: `git diff --name-only --diff-filter=ACMR <base>...HEAD`
+
+Files are filtered to `spec/**/*_spec.rb` and/or `test/**/*_test.rb`, de-duplicated, sorted, and then:
+
+- For RSpec: run once via `bundle exec rspec <files>`
+- For Rails + Minitest: run once via `rails test <files>`
+- For plain Minitest: run each file via `ruby -I test <file>`
+
+The CLI prints each full command before executing. With `--dry-run`, it only prints and exits.
+
+Notes:
+- We intentionally exclude deletions (`D`) so removed tests are not attempted to run.
+- Renames (`R`) and copies (`C`) are included, so moved tests are still executed.
+
+## Exit status
+
+- Returns non-zero if any executed command fails
+- Returns `0` if no changed/added spec files are detected
+
+## License
+
+MIT

data/bin/qc

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "shellwords"
+require "quick_check"
+
+exit(QuickCheck::CLI.start(ARGV))

data/lib/quick_check/cli.rb

@@ -0,0 +1,364 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "open3"
+require "yaml"
+require "shellwords"
+
+module QuickCheck
+  class CLI
+    DEFAULT_BASE_BRANCHES = ["main", "master"].freeze
+
+    def self.start(argv)
+      new(argv).run
+    end
+
+    def initialize(argv)
+      @argv = argv
+      @options = {
+        base_branch: nil,
+        include_committed_diff: true,
+        include_staged: true,
+        include_unstaged: true,
+        custom_command: nil,
+        print_only: false,
+        dry_run: false,
+        debug: false
+      }
+    end
+
+    def run
+      parse_options!
+
+      changed = determine_changed_test_files
+      if changed[:rspec].empty? && changed[:minitest].empty?
+        $stdout.puts("No changed/added test files detected.")
+        return 0
+      end
+
+      if @options[:print_only]
+        (changed[:rspec] + changed[:minitest]).each { |f| $stdout.puts(f) }
+        return 0
+      end
+
+      exit_status = 0
+
+      # Run RSpec files if any
+      unless changed[:rspec].empty?
+        cmd = build_command_for(:rspec, changed[:rspec])
+        print_and_maybe_run(cmd)
+        exit_status = nonzero_status(exit_status)
+      end
+
+      # Run Minitest files if any
+      unless changed[:minitest].empty?
+        minitest_cmd = build_command_for(:minitest, changed[:minitest])
+        if minitest_cmd == :per_file_minitest
+          changed[:minitest].each do |file|
+            cmd = ["ruby", "-I", "test", file]
+            print_and_maybe_run(cmd)
+            exit_status = nonzero_status(exit_status)
+          end
+        else
+          print_and_maybe_run(minitest_cmd)
+          exit_status = nonzero_status(exit_status)
+        end
+      end
+
+      exit_status
+    end
+
+    private
+
+    def parse_options!
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: qc [options]"
+
+        opts.on("--base BRANCH", "Base branch to diff against (overrides config)") do |v|
+          @options[:base_branch] = v
+        end
+
+        opts.on("--no-committed", "Do not include committed changes vs base branch") do
+          @options[:include_committed_diff] = false
+        end
+
+        opts.on("--committed", "Include committed changes vs base branch") do
+          @options[:include_committed_diff] = true
+        end
+
+        opts.on("--no-staged", "Ignore staged changes") do
+          @options[:include_staged] = false
+        end
+
+        opts.on("--no-unstaged", "Ignore unstaged changes") do
+          @options[:include_unstaged] = false
+        end
+
+        opts.on("--cmd CMD", "Override test command (auto-detected when omitted)") do |v|
+          @options[:custom_command] = Shellwords.split(v)
+        end
+
+        opts.on("-p", "--print", "Only print matched spec files, do not run") do
+          @options[:print_only] = true
+        end
+
+        opts.on("-n", "--dry-run", "Print command that would run") do
+          @options[:dry_run] = true
+        end
+
+        opts.on("-v", "--verbose", "Verbose/debug output") do
+          @options[:debug] = true
+        end
+
+        opts.on("-h", "--help", "Show help") do
+          $stdout.puts(opts)
+          exit 0
+        end
+      end
+
+      parser.parse!(@argv)
+    end
+
+    def determine_changed_test_files
+      ensure_git_repo!
+
+      base_branch = resolve_base_branch
+      files = []
+
+      if @options[:include_unstaged]
+        files.concat(git_diff_name_only(["--name-only", "--diff-filter=ACMR"]))
+        files.concat(git_untracked_files)
+      end
+
+      if @options[:include_staged]
+        files.concat(git_diff_name_only(["--name-only", "--cached", "--diff-filter=ACMR"]))
+      end
+
+      if @options[:include_committed_diff]
+        current_branch = git_current_branch
+        if current_branch && base_branch && current_branch != base_branch
+          # Include files changed on this branch vs base
+          range = diff_range_against_base(base_branch)
+          files.concat(git_diff_name_only(["--name-only", "--diff-filter=ACMR", range])) if range
+        end
+      end
+
+      files = files.compact.uniq
+      rspec_specs = files.select { |f| f.match?(%r{\Aspec/.+_spec\.rb\z}) }
+      minitest_tests = files.select { |f| f.match?(%r{\Atest/.+_test\.rb\z}) }
+
+      # Infer tests from source changes (e.g., app/models/user.rb -> spec/models/user_spec.rb)
+      source_files = files.reject { |f| f.match?(%r{\A(spec/|test/)}) }
+      unless source_files.empty?
+        inferred_rspec = source_files.flat_map { |src| infer_rspec_paths_for_source(src) }
+        inferred_minitest = source_files.flat_map { |src| infer_minitest_paths_for_source(src) }
+        rspec_specs.concat(inferred_rspec)
+        minitest_tests.concat(inferred_minitest)
+      end
+
+      { rspec: rspec_specs.uniq, minitest: minitest_tests.uniq }
+    end
+
+    def ensure_git_repo!
+      run_cmd(["git", "rev-parse", "--is-inside-work-tree"]).tap do |ok, out, _err|
+        unless ok && out.to_s.strip == "true"
+          $stderr.puts("qc must be run inside a git repository")
+          exit 2
+        end
+      end
+    end
+
+    def resolve_base_branch
+      return @options[:base_branch] if @options[:base_branch]&.strip&.length&.positive?
+
+      # Load from config file if present
+      cfg = read_config
+      if cfg && cfg["base_branch"]&.strip&.length&.positive?
+        return cfg["base_branch"].strip
+      end
+
+      # Default to first existing branch from defaults
+      DEFAULT_BASE_BRANCHES.find { |b| branch_exists?(b) } || DEFAULT_BASE_BRANCHES.first
+    end
+
+    def read_config
+      paths = possible_config_paths
+      paths.each do |path|
+        next unless File.file?(path)
+        begin
+          data = YAML.safe_load(File.read(path))
+          return data if data.is_a?(Hash)
+        rescue StandardError
+          # Ignore malformed config
+        end
+      end
+      nil
+    end
+
+    def possible_config_paths
+      cwd = Dir.pwd
+      repo_root = git_repo_root || cwd
+      [
+        File.join(cwd, ".quick_check.yml"),
+        File.join(repo_root, ".quick_check.yml")
+      ].uniq
+    end
+
+    def branch_exists?(name)
+      ok, _out, _err = run_cmd(["git", "show-ref", "--verify", "--quiet", "refs/heads/#{name}"])
+      return true if ok
+
+      # fall back to remote branch
+      ok, _out, _err = run_cmd(["git", "ls-remote", "--heads", "origin", name])
+      ok && !_out.to_s.strip.empty?
+    end
+
+    def git_current_branch
+      ok, out, _err = run_cmd(["git", "rev-parse", "--abbrev-ref", "HEAD"])
+      ok ? out.to_s.strip : nil
+    end
+
+    def git_repo_root
+      ok, out, _err = run_cmd(["git", "rev-parse", "--show-toplevel"])
+      ok ? out.to_s.strip : nil
+    end
+
+    def diff_range_against_base(base)
+      return nil unless branch_exists?(base)
+      # If upstream exists, prefer merge-base to HEAD to include all branch commits
+      # The symmetric range base...HEAD ensures we include commits unique to the branch
+      "#{base}...HEAD"
+    end
+
+    def git_diff_name_only(args)
+      cmd = ["git", "diff"] + args
+      ok, out, _err = run_cmd(cmd)
+      return [] unless ok
+
+      out.split("\n").map(&:strip).reject(&:empty?)
+    end
+
+    def git_untracked_files
+      ok, out, _err = run_cmd(["git", "ls-files", "--others", "--exclude-standard"])
+      return [] unless ok
+
+      out.split("\n").map(&:strip).reject(&:empty?)
+    end
+
+    def infer_rspec_paths_for_source(source_path)
+      candidates = []
+      if source_path.start_with?("app/")
+        rel = source_path.sub(/^app\//, "")
+        # Prefer request specs for controllers
+        if rel.start_with?("controllers/")
+          sub_rel = rel.sub(/^controllers\//, "")
+          dir = File.dirname(sub_rel)
+          dir = "" if dir == "."
+          base_with_controller = File.basename(sub_rel, ".rb")
+          base_without_controller = base_with_controller.sub(/_controller\z/, "")
+          # Common conventions for request specs
+          candidates << File.join("spec", "requests", dir, "#{base_without_controller}_spec.rb")
+          candidates << File.join("spec", "requests", dir, "#{base_with_controller}_spec.rb")
+        end
+        candidates << File.join("spec", rel).sub(/\.rb\z/, "_spec.rb")
+      elsif source_path.start_with?("lib/")
+        rel = source_path.sub(/^lib\//, "")
+        candidates << File.join("spec", "lib", rel).sub(/\.rb\z/, "_spec.rb")
+      end
+
+      candidates.select { |p| File.file?(p) }
+    end
+
+    def infer_minitest_paths_for_source(source_path)
+      candidates = []
+      if source_path.start_with?("app/")
+        rel = source_path.sub(/^app\//, "")
+        # Prefer integration/request-style tests for controllers when present
+        if rel.start_with?("controllers/")
+          sub_rel = rel.sub(/^controllers\//, "")
+          dir = File.dirname(sub_rel)
+          dir = "" if dir == "."
+          base = File.basename(sub_rel, ".rb").sub(/_controller\z/, "")
+          integration_test = File.join("test", "integration", dir, "#{base}_test.rb")
+          candidates << integration_test
+        end
+        candidates << File.join("test", rel).sub(/\.rb\z/, "_test.rb")
+      elsif source_path.start_with?("lib/")
+        rel = source_path.sub(/^lib\//, "")
+        candidates << File.join("test", "lib", rel).sub(/\.rb\z/, "_test.rb")
+      end
+
+      candidates.select { |p| File.file?(p) }
+    end
+
+    def build_command_for(framework, files)
+      return (@options[:custom_command] + files) if @options[:custom_command]
+
+      case framework
+      when :rspec
+        ["bundle", "exec", "rspec"] + files
+      when :minitest
+        if rails_available?
+          rails_cmd + ["test"] + files
+        else
+          # Fallback: run per-file using ruby -Itest
+          :per_file_minitest
+        end
+      else
+        files
+      end
+    end
+
+    def rails_available?
+      bin_rails = File.join(Dir.pwd, "bin", "rails")
+      File.executable?(bin_rails) || File.file?(bin_rails) || gemfile_includes?("rails")
+    end
+
+    def rails_cmd
+      bin_rails = File.join(Dir.pwd, "bin", "rails")
+      if File.executable?(bin_rails) || File.file?(bin_rails)
+        [File.join("bin", "rails")]
+      else
+        ["bundle", "exec", "rails"]
+      end
+    end
+
+    def gemfile_includes?(gem_name)
+      gemfile_paths = [File.join(Dir.pwd, "Gemfile"), File.join(Dir.pwd, "gems.rb")]
+      gemfile_paths.any? do |path|
+        next false unless File.file?(path)
+        begin
+          content = File.read(path)
+          content.match?(/\bgem\s+["']#{Regexp.escape(gem_name)}["']/)
+        rescue StandardError
+          false
+        end
+      end
+    end
+
+    def print_and_maybe_run(cmd)
+      if cmd.is_a?(Array)
+        $stdout.puts(cmd.shelljoin)
+        return if @options[:dry_run]
+        system(*cmd)
+      else
+        # no-op for symbols like :per_file_minitest (handled by caller)
+      end
+    end
+
+    def nonzero_status(current_status)
+      return current_status if @options[:dry_run]
+      last = $?.exitstatus
+      if last && last != 0
+        last
+      else
+        current_status
+      end
+    end
+
+    def run_cmd(cmd)
+      stdout, stderr, status = Open3.capture3(*cmd)
+      [status.success?, stdout, stderr]
+    end
+  end
+end

data/lib/quick_check/version.rb

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

data/lib/quick_check.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require "quick_check/version"
+require "quick_check/cli"

data/spec/quick_check/cli_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "stringio"
+
+RSpec.describe QuickCheck::CLI do
+  def run_cli(argv, git_outputs: {}, existing_files: [])
+    stdout_io = StringIO.new
+    stderr_io = StringIO.new
+
+    allow($stdout).to receive(:puts) { |msg| stdout_io.puts(msg) }
+    allow($stderr).to receive(:puts) { |msg| stderr_io.puts(msg) }
+
+    # Stub filesystem for File.file?
+    allow(File).to receive(:file?) do |path|
+      existing_files.include?(path)
+    end
+
+    # Stub Dir.pwd
+    allow(Dir).to receive(:pwd).and_return(Dir.pwd)
+
+    # Stub Open3.capture3 for git commands
+    allow(Open3).to receive(:capture3) do |*cmd|
+      key = cmd.join(" ")
+      if git_outputs.key?(key)
+        out = git_outputs[key]
+        [out[:stdout] || "", out[:stderr] || "", instance_double(Process::Status, success?: out.fetch(:success, true), exitstatus: out.fetch(:exitstatus, 0))]
+      else
+        # Default: success with empty output
+        ["", "", instance_double(Process::Status, success?: true, exitstatus: 0)]
+      end
+    end
+
+    status = described_class.start(argv)
+    [status, stdout_io.string, stderr_io.string]
+  end
+
+  let(:base_git_stubs) do
+    {
+      "git rev-parse --is-inside-work-tree" => { stdout: "true\n" },
+      "git rev-parse --abbrev-ref HEAD" => { stdout: "feature\n" },
+      "git rev-parse --show-toplevel" => { stdout: Dir.pwd + "\n" },
+      "git show-ref --verify --quiet refs/heads/main" => { success: false, exitstatus: 1 },
+      "git ls-remote --heads origin main" => { stdout: "refs/heads/main\n" }
+    }
+  end
+
+  it "prints and exits when no changed tests" do
+    status, out, _err = run_cli([], git_outputs: base_git_stubs)
+    expect(status).to eq(0)
+    expect(out).to include("No changed/added test files detected.")
+  end
+
+  it "runs rspec for changed rspec files" do
+    stubs = base_git_stubs.merge(
+      "git diff --name-only --diff-filter=ACMR" => { stdout: "spec/models/user_spec.rb\n" }
+    )
+
+    status, out, _err = run_cli(["--dry-run"], git_outputs: stubs)
+    expect(status).to eq(0)
+    expect(out.lines.map(&:strip)).to include("bundle exec rspec spec/models/user_spec.rb")
+  end
+
+  it "infers rspec from app source change" do
+    stubs = base_git_stubs.merge(
+      "git diff --name-only --diff-filter=ACMR" => { stdout: "app/models/user.rb\n" }
+    )
+    status, out, _err = run_cli(["--dry-run"], git_outputs: stubs, existing_files: [
+      File.join("spec", "models", "user_spec.rb")
+    ])
+    expect(status).to eq(0)
+    expect(out).to include("bundle exec rspec spec/models/user_spec.rb")
+  end
+
+  it "maps controller to request spec with both base names" do
+    stubs = base_git_stubs.merge(
+      "git diff --name-only --diff-filter=ACMR" => { stdout: "app/controllers/account/users_controller.rb\n" }
+    )
+    existing = [
+      File.join("spec", "requests", "account", "users_spec.rb"),
+      File.join("spec", "requests", "account", "users_controller_spec.rb")
+    ]
+    status, out, _err = run_cli(["--dry-run"], git_outputs: stubs, existing_files: existing)
+    expect(out).to include("bundle exec rspec spec/requests/account/users_spec.rb spec/requests/account/users_controller_spec.rb")
+    expect(status).to eq(0)
+  end
+
+  it "falls back to controller spec when no request spec exists" do
+    stubs = base_git_stubs.merge(
+      "git diff --name-only --diff-filter=ACMR" => { stdout: "app/controllers/home_controller.rb\n" }
+    )
+    existing = [File.join("spec", "controllers", "home_controller_spec.rb")]
+    status, out, _err = run_cli(["--dry-run"], git_outputs: stubs, existing_files: existing)
+    expect(out).to include("bundle exec rspec spec/controllers/home_controller_spec.rb")
+    expect(status).to eq(0)
+  end
+
+  it "runs minitest through rails test when test files change and rails present" do
+    stubs = base_git_stubs.merge(
+      "git diff --name-only --diff-filter=ACMR" => { stdout: "test/models/user_test.rb\n" }
+    )
+    allow_any_instance_of(QuickCheck::CLI).to receive(:rails_available?).and_return(true)
+    status, out, _err = run_cli(["--dry-run"], git_outputs: stubs, existing_files: [File.join("bin", "rails")])
+    expect(out).to include("bundle exec rails test test/models/user_test.rb")
+    expect(status).to eq(0)
+  end
+
+  it "runs per-file minitest when no rails" do
+    stubs = base_git_stubs.merge(
+      "git diff --name-only --diff-filter=ACMR" => { stdout: "test/models/user_test.rb\n" }
+    )
+
+    status, out, _err = run_cli(["--dry-run"], git_outputs: stubs)
+    expect(out.lines.map(&:strip)).to include("ruby -I test test/models/user_test.rb")
+    expect(status).to eq(0)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "quick_check"
+require "open3"
+
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+  config.order = :random
+  Kernel.srand config.seed
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: quick_check
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kasvit
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-08-22 00:00:00.000000000 Z
+dependencies: []
+description: Adds the `qc` command to run only changed or newly added RSpec files
+  from uncommitted changes and vs base branch (main/master).
+email:
+- kasvit93@gmail.com
+executables:
+- qc
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- LICENSE.txt
+- README.md
+- bin/qc
+- lib/quick_check.rb
+- lib/quick_check/cli.rb
+- lib/quick_check/version.rb
+- spec/quick_check/cli_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/kasvit/quick_check
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: Run changed/added RSpec specs quickly
+test_files: []