red_dot 0.1.0

data/lib/red_dot/cli.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RedDot
+  class Cli
+    def self.parse(argv = ARGV)
+      args = argv.dup
+      overrides = {}
+      dir = nil
+      i = 0
+      while i < args.size
+        arg = args[i]
+        case arg
+        when '--format', '-f'
+          overrides[:format] = args[i + 1] if args[i + 1] && !args[i + 1].start_with?('-')
+          i += 2
+        when '--tag', '-t'
+          (overrides[:tags] ||= []) << args[i + 1] if args[i + 1] && !args[i + 1].start_with?('-')
+          i += 2
+        when '--out', '-o'
+          overrides[:out_path] = args[i + 1] if args[i + 1]
+          i += 2
+        when '--example', '-e'
+          overrides[:example_filter] = args[i + 1] if args[i + 1]
+          i += 2
+        when '--line', '-l'
+          overrides[:line_number] = args[i + 1] if args[i + 1] && !args[i + 1].start_with?('-')
+          i += 2
+        when '--fail-fast'
+          overrides[:fail_fast] = true
+          i += 1
+        when /^[^-]/
+          dir = arg
+          i += 1
+        else
+          i += 1
+        end
+      end
+      { working_dir: dir || Dir.pwd, option_overrides: overrides }
+    end
+  end
+end

data/lib/red_dot/config.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module RedDot
+  class Config
+    VALID_EDITORS = %w[vscode cursor textmate].freeze
+
+    DEFAULT_OPTIONS = {
+      tags: [],
+      tags_str: '',
+      format: 'progress',
+      out_path: '',
+      example_filter: '',
+      line_number: '',
+      fail_fast: false,
+      seed: '',
+      editor: 'cursor'
+    }.freeze
+
+    def self.user_config_path
+      base = ENV.fetch('XDG_CONFIG_HOME', File.join(Dir.home, '.config'))
+      File.join(base, 'red_dot', 'config.yml')
+    end
+
+    def self.project_config_path(working_dir)
+      File.join(File.expand_path(working_dir), '.red_dot.yml')
+    end
+
+    def self.load(working_dir: Dir.pwd)
+      opts = DEFAULT_OPTIONS.dup
+      project_path = project_config_path(working_dir)
+      if File.readable?(project_path)
+        opts = merge_file(opts, user_config_path)
+        opts = merge_file(opts, project_path)
+      end
+      opts
+    end
+
+    def self.merge_file(opts, path)
+      return opts unless path && File.readable?(path)
+
+      raw = YAML.safe_load_file(path, permitted_classes: [Symbol])
+      return opts unless raw.is_a?(Hash)
+
+      opts = opts.dup
+      opts[:tags] = array_or_parse(opts[:tags], raw['tags'], raw['tags_str'])
+      opts[:tags_str] = raw['tags_str'].to_s.strip if raw.key?('tags_str')
+      opts[:tags_str] = (raw['tags'] || []).join(', ') if raw.key?('tags') && raw['tags'].is_a?(Array)
+      opts[:format] = raw['format'].to_s.strip if raw.key?('format') && !raw['format'].to_s.strip.empty?
+      opts[:out_path] = raw['output'].to_s if raw.key?('output')
+      opts[:out_path] = raw['out_path'].to_s if raw.key?('out_path') && !raw.key?('output')
+      opts[:example_filter] = raw['example_filter'].to_s if raw.key?('example_filter')
+      opts[:line_number] = raw['line_number'].to_s if raw.key?('line_number')
+      opts[:fail_fast] = raw['fail_fast'] ? true : false if raw.key?('fail_fast')
+      opts[:seed] = raw['seed'].to_s.strip if raw.key?('seed')
+      if raw.key?('editor')
+        val = raw['editor'].to_s.strip.downcase
+        opts[:editor] = val if VALID_EDITORS.include?(val)
+      end
+      opts
+    end
+
+    def self.array_or_parse(existing, tags_val, tags_str_val)
+      if tags_val.is_a?(Array)
+        tags_val.map(&:to_s).reject(&:empty?)
+      elsif tags_str_val.to_s.strip != ''
+        tags_str_val.to_s.split(/[\s,]+/).map(&:strip).reject(&:empty?)
+      else
+        existing
+      end
+    end
+
+    def self.component_roots(working_dir: Dir.pwd)
+      path = project_config_path(working_dir)
+      return nil unless File.readable?(path)
+
+      raw = YAML.safe_load_file(path, permitted_classes: [Symbol])
+      return nil unless raw.is_a?(Hash) && raw.key?('components')
+      return nil unless raw['components'].is_a?(Array)
+
+      raw['components'].map(&:to_s).reject(&:empty?)
+    end
+  end
+end

data/lib/red_dot/example_discovery.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'fileutils'
+require 'json'
+require 'tmpdir'
+
+module RedDot
+  class ExampleDiscovery
+    ExampleInfo = Struct.new(:path, :line_number, :full_description, keyword_init: true)
+
+    CACHE_DIR = File.join(Dir.tmpdir, 'red_dot').freeze
+
+    def self.cache_file_path(working_dir)
+      hash = Digest::SHA256.hexdigest(File.expand_path(working_dir))[0, 16]
+      File.join(CACHE_DIR, "cache_#{hash}.json")
+    end
+
+    def self.read_cache_file(working_dir)
+      path = cache_file_path(working_dir)
+      return {} unless File.readable?(path)
+
+      raw = File.read(path)
+      return {} if raw.strip.empty?
+
+      data = JSON.parse(raw)
+      data['entries'] || {}
+    rescue JSON::ParserError, Errno::ENOENT
+      {}
+    end
+
+    def self.get_cached_examples(working_dir, path)
+      full_path = File.join(working_dir, path)
+      return nil unless File.exist?(full_path)
+
+      entries = read_cache_file(working_dir)
+      entry = entries[path]
+      return nil unless entry
+
+      current_mtime = File.mtime(full_path).to_f
+      return nil unless current_mtime == entry['mtime']
+
+      (entry['examples'] || []).map do |ex|
+        ExampleInfo.new(
+          path: ex['path'],
+          line_number: ex['line_number'],
+          full_description: ex['full_description'].to_s
+        )
+      end
+    end
+
+    def self.write_cached_examples(working_dir, path, examples)
+      full_path = File.join(working_dir, path)
+      mtime = File.exist?(full_path) ? File.mtime(full_path).to_f : 0
+      entries = read_cache_file(working_dir)
+      entries[path] = {
+        'mtime' => mtime,
+        'examples' => examples.map do |e|
+          { 'path' => e.path, 'line_number' => e.line_number, 'full_description' => e.full_description }
+        end
+      }
+      FileUtils.mkdir_p(CACHE_DIR)
+      File.write(cache_file_path(working_dir), JSON.generate({ 'entries' => entries }))
+    end
+
+    def self.discover(working_dir:, path:)
+      json_path = RspecRunner.run_dry_run(working_dir: working_dir, paths: [path])
+      return [] unless json_path && File.readable?(json_path)
+
+      raw = File.read(json_path)
+      return [] if raw.strip.empty?
+
+      data = JSON.parse(raw)
+      examples = (data['examples'] || []).map do |ex|
+        ExampleInfo.new(
+          path: ex['file_path'],
+          line_number: ex['line_number'],
+          full_description: ex['full_description'].to_s
+        )
+      end
+      write_cached_examples(working_dir, path, examples)
+      examples
+    rescue JSON::ParserError, Errno::ENOENT
+      []
+    end
+  end
+end

data/lib/red_dot/rspec_result.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module RedDot
+  class RspecResult
+    Example = Struct.new(
+      :description, :full_description, :status, :file_path, :line_number, :exception_message,
+      :run_time, :pending_message, keyword_init: true
+    )
+
+    attr_reader :summary_line, :examples, :duration, :errors_outside_of_examples, :seed
+
+    def initialize(summary_line:, examples:, duration: nil, errors_outside_of_examples: 0, seed: nil)
+      @summary_line = summary_line
+      @examples = examples
+      @duration = duration
+      @errors_outside_of_examples = errors_outside_of_examples.to_i
+      @seed = seed
+    end
+
+    def self.from_json_path(path)
+      return nil unless path && File.readable?(path)
+
+      raw = File.read(path)
+      return nil if raw.strip.empty?
+
+      data = JSON.parse(raw)
+      examples = (data['examples'] || []).map do |ex|
+        exception_msg = ex.dig('exception', 'message')
+        raw_run_time = ex['run_time']
+        run_time = if raw_run_time.is_a?(Numeric)
+                     Float(raw_run_time)
+                   elsif raw_run_time.is_a?(String) && !raw_run_time.strip.empty?
+                     Float(raw_run_time)
+                   end
+        Example.new(
+          description: ex['description'],
+          full_description: ex['full_description'],
+          status: ex['status']&.to_sym,
+          file_path: ex['file_path'],
+          line_number: ex['line_number'],
+          exception_message: exception_msg,
+          run_time: run_time,
+          pending_message: ex['pending_message']
+        )
+      end
+      summary = data['summary'] || {}
+      new(
+        summary_line: data['summary_line'] || '',
+        examples: examples,
+        duration: summary['duration'],
+        errors_outside_of_examples: summary['errors_outside_of_examples_count'],
+        seed: data['seed']
+      )
+    end
+
+    def passed_count
+      examples.count { |e| e.status == :passed }
+    end
+
+    def failed_count
+      examples.count { |e| e.status == :failed }
+    end
+
+    def pending_count
+      examples.count { |e| e.status == :pending }
+    end
+
+    def failed_examples
+      examples.select { |e| e.status == :failed }
+    end
+
+    def pending_examples
+      examples.select { |e| e.status == :pending }
+    end
+
+    def failure_locations
+      failed_examples.map { |e| e.line_number ? "#{e.file_path}:#{e.line_number}" : e.file_path }.uniq
+    end
+
+    def examples_with_run_time
+      examples.select { |e| e.run_time.is_a?(Numeric) && e.run_time.positive? }
+    end
+
+    def slowest_examples(count = 5)
+      examples_with_run_time.max_by(count, &:run_time)
+    end
+
+    def fastest_examples(count = 5)
+      examples_with_run_time.min_by(count, &:run_time)
+    end
+
+    def slowest_files(count = 5)
+      by_file = examples_with_run_time.group_by(&:file_path)
+      by_file.transform_values { |exs| exs.sum(&:run_time) }
+             .max_by(count) { |_path, total| total }
+             .map { |path, total| [path, total] }
+    end
+  end
+end

data/lib/red_dot/rspec_runner.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+
+module RedDot
+  class RspecRunner
+    def self.spawn(working_dir:, paths:, tags: [], format: 'progress', out_path: nil,
+                   example_filter: nil, fail_fast: false, seed: nil)
+      json_file = Tempfile.new(['red_dot', '.json'])
+      json_path = json_file.path
+      json_file.close
+      json_file.unlink
+
+      argv = build_argv(
+        paths: paths,
+        json_path: json_path,
+        format: format,
+        out_path: out_path,
+        tags: tags,
+        example_filter: example_filter,
+        fail_fast: fail_fast,
+        seed: seed
+      )
+
+      stdout_r, stdout_w = IO.pipe
+      stdout_w.close_on_exec = true
+
+      env = {}
+      env['BUNDLE_GEMFILE'] = File.join(working_dir, 'Gemfile') if File.file?(File.join(working_dir, 'Gemfile'))
+
+      cmd = rspec_command(working_dir)
+      pid = Kernel.spawn(env, *cmd, *argv, out: stdout_w, err: stdout_w, chdir: working_dir)
+      stdout_w.close
+
+      { pid: pid, stdout_io: stdout_r, json_path: json_path }
+    end
+
+    def self.build_argv(paths:, json_path:, format: 'progress', out_path: nil, tags: [],
+                        example_filter: nil, fail_fast: false, seed: nil)
+      argv = paths.dup
+      argv << '--format' << 'json' << '--out' << json_path
+      argv << '--format' << format
+      tags.each { |t| argv << '--tag' << t }
+      argv << '--out' << out_path if out_path.to_s.strip != ''
+      argv << '--example' << example_filter if example_filter.to_s.strip != ''
+      argv << '--fail-fast' if fail_fast
+      argv << '--seed' << seed.to_s.strip if seed.to_s.strip =~ /\A\d+\z/
+      argv
+    end
+
+    def self.rspec_command(working_dir)
+      gemfile = File.join(working_dir, 'Gemfile')
+      File.file?(gemfile) ? %w[bundle exec rspec] : ['rspec']
+    end
+
+    def self.run_dry_run(working_dir:, paths:)
+      json_file = Tempfile.new(['red_dot_list', '.json'])
+      json_path = json_file.path
+      json_file.close
+      json_file.unlink
+      argv = paths.dup
+      argv << '--dry-run' << '--format' << 'json' << '--out' << json_path
+      env = {}
+      env['BUNDLE_GEMFILE'] = File.join(working_dir, 'Gemfile') if File.file?(File.join(working_dir, 'Gemfile'))
+      cmd = rspec_command(working_dir)
+      pid = Kernel.spawn(env, *cmd, *argv, out: File::NULL, err: File::NULL, chdir: working_dir)
+      Process.wait(pid)
+      json_path
+    end
+  end
+end

data/lib/red_dot/spec_discovery.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module RedDot
+  class SpecDiscovery
+    DEFAULT_SPEC_DIR = 'spec'
+    DEFAULT_PATTERN = '**/*_spec.rb'
+    COMPONENTS_DIR = 'components'
+
+    def initialize(working_dir: Dir.pwd)
+      @working_dir = File.expand_path(working_dir)
+    end
+
+    def umbrella?
+      components_dir = File.join(@working_dir, COMPONENTS_DIR)
+      File.directory?(components_dir)
+    end
+
+    def component_roots
+      return [] unless umbrella?
+
+      explicit = Config.component_roots(working_dir: @working_dir)
+      return explicit.map { |r| r == '.' ? '' : r } if explicit&.any?
+
+      roots = []
+      root_spec_dir = spec_dir_for_root
+      roots << '' if root_spec_dir && Dir.exist?(File.join(@working_dir, root_spec_dir))
+
+      comp_dir = File.join(@working_dir, COMPONENTS_DIR)
+      return roots unless Dir.exist?(comp_dir)
+
+      Dir.children(comp_dir).each do |name|
+        next unless File.directory?(File.join(comp_dir, name))
+
+        comp_path = "#{COMPONENTS_DIR}/#{name}"
+        comp_spec = File.join(@working_dir, comp_path, DEFAULT_SPEC_DIR)
+        roots << comp_path if Dir.exist?(comp_spec)
+      end
+      roots.sort
+    end
+
+    def spec_dir
+      if umbrella?
+        return File.join(@working_dir, DEFAULT_SPEC_DIR) if component_roots.empty?
+
+        first = component_roots.first
+        base = first.empty? ? @working_dir : File.join(@working_dir, first)
+        spec_subdir = read_default_path_from_rspec(base) || DEFAULT_SPEC_DIR
+        return File.join(base, spec_subdir)
+      end
+
+      path = read_default_path_from_rspec(@working_dir)
+      base = path || DEFAULT_SPEC_DIR
+      File.join(@working_dir, base)
+    end
+
+    def relative_spec_path
+      read_default_path_from_rspec(@working_dir) || DEFAULT_SPEC_DIR
+    end
+
+    def discover
+      if umbrella?
+        discover_umbrella
+      else
+        discover_single
+      end
+    end
+
+    def discover_grouped_by_dir
+      files = discover
+      files.group_by { |f| File.dirname(f) }.transform_values(&:sort)
+    end
+
+    def run_context_for(display_path)
+      if umbrella?
+        run_context_umbrella(display_path)
+      else
+        { run_cwd: @working_dir, rspec_path: display_path }
+      end
+    end
+
+    def default_run_all_paths
+      if umbrella?
+        flat_spec_list_for_umbrella
+      else
+        [relative_spec_path]
+      end
+    end
+
+    def empty_state_message
+      if umbrella? && component_roots.empty?
+        "No spec directory or components with spec/ found in #{@working_dir}"
+      else
+        "No spec files in #{spec_dir}"
+      end
+    end
+
+    private
+
+    def spec_dir_for_root
+      read_default_path_from_rspec(@working_dir) || DEFAULT_SPEC_DIR
+    end
+
+    def read_default_path_from_rspec(dir)
+      rspec_file = File.join(dir, '.rspec')
+      return nil unless File.readable?(rspec_file)
+
+      line = File.readlines(rspec_file).find { |l| l.strip.start_with?('--default-path') }
+      return nil unless line
+
+      line.sub(/\A--default-path\s+/, '').strip
+    end
+
+    def discover_single
+      dir = spec_dir
+      return [] unless dir && Dir.exist?(dir)
+
+      pattern = File.join(dir, DEFAULT_PATTERN)
+      Dir.glob(pattern).map { |p| Pathname.new(p).relative_path_from(Pathname.new(@working_dir)).to_s }.sort
+    end
+
+    def discover_umbrella
+      roots = component_roots
+      return [] if roots.empty?
+
+      files = []
+      roots.each do |component_root|
+        base = component_root.empty? ? @working_dir : File.join(@working_dir, component_root)
+        spec_path = read_default_path_from_rspec(base) || DEFAULT_SPEC_DIR
+        spec_full = File.join(base, spec_path)
+        next unless Dir.exist?(spec_full)
+
+        pattern = File.join(spec_full, DEFAULT_PATTERN)
+        Dir.glob(pattern).each do |p|
+          rel = Pathname.new(p).relative_path_from(Pathname.new(@working_dir)).to_s
+          files << rel
+        end
+      end
+      files.sort
+    end
+
+    def flat_spec_list_for_umbrella
+      discover
+    end
+
+    def run_context_umbrella(display_path)
+      path_str = display_path.to_s
+      line_suffix = nil
+      if path_str =~ /\A(.+):(\d+)\z/
+        path_str = Regexp.last_match(1)
+        line_suffix = ":#{Regexp.last_match(2)}"
+      end
+
+      roots = component_roots
+      roots_with_prefix = roots.map do |r|
+        base = r.empty? ? @working_dir : File.join(@working_dir, r)
+        spec_subdir = read_default_path_from_rspec(base) || DEFAULT_SPEC_DIR
+        prefix = r.empty? ? "#{spec_subdir}/" : "#{r}/#{spec_subdir}/"
+        [r, prefix]
+      end
+      roots_with_prefix.sort_by! { |_r, p| -p.length }
+
+      roots_with_prefix.each do |component_root, prefix|
+        next unless path_str == prefix.chomp('/') || path_str.start_with?(prefix)
+
+        run_cwd = component_root.empty? ? @working_dir : File.join(@working_dir, component_root)
+        rspec_path = if component_root.empty?
+                       path_str
+                     else
+                       path_str.sub(%r{\A#{Regexp.escape(component_root)}/?}, '')
+                     end
+        rspec_path += line_suffix if line_suffix
+        return { run_cwd: run_cwd, rspec_path: rspec_path }
+      end
+
+      { run_cwd: @working_dir, rspec_path: display_path }
+    end
+  end
+end

data/lib/red_dot/version.rb

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

data/lib/red_dot.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'red_dot/version'
+require_relative 'red_dot/config'
+require_relative 'red_dot/cli'
+require_relative 'red_dot/spec_discovery'
+require_relative 'red_dot/example_discovery'
+require_relative 'red_dot/rspec_result'
+require_relative 'red_dot/rspec_runner'
+require_relative 'red_dot/app'
+
+module RedDot
+  class Error < StandardError; end
+
+  def self.run(working_dir: Dir.pwd, option_overrides: {})
+    unless $stdout.tty?
+      warn 'Error: red_dot (rdot) requires a TTY. Run from a terminal.'
+      exit 1
+    end
+    app = RedDot::App.new(working_dir: working_dir, option_overrides: option_overrides)
+    Bubbletea.run(app, alt_screen: true)
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: red_dot
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Lovell McIlwain
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-03-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bubbletea
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: lipgloss
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description: |-
+  A lazy-like TUI for running RSpec tests: select files, set options (tags, format, output, seed), " \
+    "run all/some/one, view results, and rerun.
+email:
+- ''
+executables:
+- rdot
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- exe/rdot
+- lib/red_dot.rb
+- lib/red_dot/app.rb
+- lib/red_dot/cli.rb
+- lib/red_dot/config.rb
+- lib/red_dot/example_discovery.rb
+- lib/red_dot/rspec_result.rb
+- lib/red_dot/rspec_runner.rb
+- lib/red_dot/spec_discovery.rb
+- lib/red_dot/version.rb
+homepage: https://github.com/vmcilwain/red_dot
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/vmcilwain/red_dot
+  source_code_uri: https://github.com/vmcilwain/red_dot
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key:
+specification_version: 4
+summary: Terminal UI for running RSpec tests (hopefully easier)
+test_files: []