ruby_raider 2.0.0 → 3.0.0

data/sig/scaffolding/dry_run_presenter.rbs

@@ -0,0 +1,4 @@
+# Type definitions for DryRunPresenter
+module DryRunPresenter
+  def self?.preview: (Array[String] planned_files) -> Array[String]
+end

data/sig/scaffolding/name_normalizer.rbs

@@ -0,0 +1,17 @@
+# Type definitions for NameNormalizer
+module NameNormalizer
+  SUFFIXES: Array[String]
+
+  def self?.normalize: (String input) -> String
+  def self?.to_class_name: (String input, String suffix) -> String
+  def self?.to_page_class: (String input) -> String
+  def self?.to_file_name: (String input) -> String
+  def self?.nested?: (String input) -> bool
+  def self?.module_parts: (String input) -> Array[String]
+  def self?.leaf_name: (String input) -> String
+
+  private
+
+  def self?.camel_to_snake: (String str) -> String
+  def self?.strip_suffixes: (String name) -> String
+end

data/sig/scaffolding/page_introspector.rbs

@@ -0,0 +1,14 @@
+# Type definitions for PageIntrospector
+class PageIntrospector
+  SKIP_METHODS: Array[String]
+
+  attr_reader class_name: String
+  attr_reader methods: Array[Hash[Symbol, untyped]]
+
+  def initialize: (String file_path) -> void
+
+  private
+
+  def extract_class_name: () -> String
+  def extract_public_methods: () -> Array[Hash[Symbol, untyped]]
+end

data/sig/scaffolding/project_detector.rbs

@@ -0,0 +1,14 @@
+# Type definitions for ScaffoldProjectDetector
+module ScaffoldProjectDetector
+  AUTOMATION_GEMS: Hash[String, String]
+  FRAMEWORK_GEMS: Hash[String, String]
+
+  def self?.detect: () -> Hash[Symbol, String | bool | nil]
+  def self?.detect_automation: (?String? gemfile) -> String
+  def self?.detect_framework: (?String? gemfile) -> String
+  def self?.read_gemfile: () -> String
+  def self?.selenium?: () -> bool
+  def self?.capybara?: () -> bool
+  def self?.watir?: () -> bool
+  def self?.config: () -> Hash[String, untyped]
+end

data/sig/scaffolding/scaffold_menu.rbs

@@ -0,0 +1,18 @@
+# Type definitions for ScaffoldMenu
+class ScaffoldMenu
+  COMPONENTS: Hash[String, Symbol]
+
+  def initialize: () -> void
+  def run: () -> Hash[Symbol, untyped]?
+  def self.build_options: (names: Array[String] | String, components: Array[Symbol] | Symbol, ?uses: Array[String] | String) -> Hash[Symbol, untyped]
+
+  private
+
+  def ask_names: () -> Array[String]
+  def ask_components: () -> Array[Symbol]
+  def ask_relationships: () -> Array[String]
+  def preview_and_confirm: (Array[String] names, Array[Symbol] components, Array[String] uses) -> Hash[Symbol, untyped]?
+  def planned_files: (Array[String] names, Array[Symbol] components) -> Array[String]
+  def file_for: (String name, Symbol component) -> String?
+  def default_components: (Hash[Symbol, untyped] project) -> Array[String]
+end

data/sig/scaffolding/scaffolding.rbs

@@ -0,0 +1,55 @@
+# Type definitions for Scaffolding
+class Scaffolding < Thor::Group
+  include Thor::Actions
+
+  OVERRIDE_DIR: String
+
+  attr_writer uses: Array[String]
+
+  def self.source_root: () -> String
+  def self.planned_path: (String name, String type, ?String? custom_path) -> String?
+
+  # Generation methods
+  def generate_page: () -> void
+  def generate_feature: () -> void
+  def generate_spec: () -> void
+  def generate_helper: () -> void
+  def generate_steps: () -> void
+  def generate_component: () -> void
+  def generate_config: () -> void
+  def generate_spec_from_page: (String source_file, ?ai: bool) -> void
+  def generate_page_from_url: (Hash[Symbol, untyped] analysis) -> void
+  def generate_spec_from_url: (Hash[Symbol, untyped] analysis) -> void
+
+  # Deletion methods
+  def delete_page: () -> void
+  def delete_feature: () -> void
+  def delete_spec: () -> void
+  def delete_helper: () -> void
+  def delete_steps: () -> void
+  def delete_component: () -> void
+  def delete_config: () -> void
+
+  # Template helpers
+  def class_name: () -> String?
+  def page_class_name: () -> String
+  def normalized_name: () -> String
+  def nested?: () -> bool
+  def module_parts: () -> Array[String]
+  def leaf_name: () -> String
+  def automation_type: () -> String
+  def framework_type: () -> String
+  def project_config: () -> Hash[String, untyped]
+  def selenium?: () -> bool
+  def capybara?: () -> bool
+  def watir?: () -> bool
+  def uses_list: () -> Array[String]
+  def introspected: () -> PageIntrospector?
+  def url_data: () -> Hash[Symbol, untyped]?
+  def ai_scenarios: () -> Hash[Symbol, untyped]
+  def default_path: (String standard_path, String file_type) -> String
+
+  private
+
+  def enrich_with_ai_scenarios: () -> void
+end

data/sig/scaffolding/url_analyzer.rbs

@@ -0,0 +1,28 @@
+# Type definitions for UrlAnalyzer
+class UrlAnalyzer
+  INTERACTIVE_TAGS: Array[String]
+
+  attr_reader url: String
+  attr_reader page_name: String
+  attr_reader elements: Array[Hash[Symbol, untyped]]
+
+  def initialize: (String url, ?name_override: String?, ?ai: bool) -> void
+  def analyze: () -> UrlAnalyzer
+  def to_h: () -> Hash[Symbol, untyped]
+
+  private
+
+  def fetch_html: () -> String
+  def parse_elements: (String html) -> void
+  def parse_inputs: (String html) -> void
+  def parse_selects: (String html) -> void
+  def parse_textareas: (String html) -> void
+  def parse_buttons: (String html) -> void
+  def parse_links: (String html) -> void
+  def parse_attributes: (String attr_string) -> Hash[String, String]
+  def best_locator: (Hash[String, String] attrs, ?text: String?) -> Hash[Symbol, Symbol | String]
+  def infer_tag: (Hash[String, String] attrs) -> String
+  def build_element: (name: String, type: Symbol, locator: Hash[Symbol, Symbol | String], **untyped extra) -> Hash[Symbol, untyped]
+  def analyze_with_llm: (String html) -> Array[Hash[Symbol, untyped]]?
+  def derive_page_name: () -> String
+end

data/sig/utilities/desktop_downloader.rbs

@@ -0,0 +1,23 @@
+# Type definitions for DesktopDownloader
+module DesktopDownloader
+  REPO: String
+  API_URL: String
+  PLATFORM_PATTERNS: Hash[String, Regexp]
+
+  def self?.download: (?String? destination_dir) -> String?
+  def self?.latest_version: () -> String?
+  def self?.download_url: () -> String?
+  def self?.clear_cache: () -> void
+  def self?.platform: () -> String
+  def self?.platform_display_name: () -> String
+
+  private
+
+  def self?.find_asset: () -> Hash[Symbol, untyped]?
+  def self?.fetch_latest_release: () -> Hash[String, untyped]?
+  def self?.download_file: (String url, String destination) -> void
+  def self?.follow_redirects: (URI::Generic uri, String destination, ?Integer limit) -> void
+  def self?.write_response: (Net::HTTPResponse response, String destination) -> void
+  def self?.print_progress: (Integer downloaded, Integer total) -> void
+  def self?.default_download_dir: () -> String
+end

data/sig/utilities/logger.rbs

@@ -0,0 +1,13 @@
+# Type definitions for RubyRaider::Logger
+module RubyRaider
+  module Logger
+    extend Forwardable
+
+    def self?.logger: () -> ::Logger
+    def self?.fatal: (*untyped args) -> void
+    def self?.error: (*untyped args) -> void
+    def self?.warn: (*untyped args) -> void
+    def self?.info: (*untyped args) -> void
+    def self?.debug: (*untyped args) -> void
+  end
+end

data/sig/utilities/logo.rbs

@@ -0,0 +1,16 @@
+# Type definitions for Logo
+module RubyRaider
+  module Logo
+    PALETTE: Hash[Integer, String]
+    GEM: Array[Array[Integer]]
+    GLYPHS: Hash[String, Array[Array[Integer]]]
+    TEXT_COLOR: Integer
+
+    def self.display: () -> void
+
+    private
+
+    def self.halfblock: (Integer top, Integer bot) -> String
+    def self.build_text: (String str) -> Array[Array[Integer]]
+  end
+end

data/sig/utilities/utilities.rbs

@@ -0,0 +1,30 @@
+# Type definitions for Utilities
+module Utilities
+  @path: String
+
+  def self?.browser=: (String browser) -> void
+  def self?.page_path=: (String path) -> void
+  def self?.spec_path=: (String path) -> void
+  def self?.feature_path=: (String path) -> void
+  def self?.helper_path=: (String path) -> void
+  def self?.url=: (String url) -> void
+  def self?.timeout=: (String | Integer seconds) -> void
+  def self?.viewport=: (String dimensions) -> void
+  def self?.platform=: (String platform) -> void
+  def self?.browser_options=: (Array[String] opts) -> void
+  def self?.delete_browser_options: () -> void
+  def self?.llm_provider=: (String provider) -> void
+  def self?.llm_api_key=: (String key) -> void
+  def self?.llm_model=: (String model) -> void
+  def self?.llm_url=: (String url) -> void
+  def self?.debug=: (bool enabled) -> void
+  def self?.batch_update: (**untyped settings) -> void
+  def self?.run: (?String? opts) -> void
+  def self?.parallel_run: (?String? opts, ?untyped? _settings) -> void
+
+  private
+
+  def self?.set: (String key, untyped value) -> void
+  def self?.overwrite_yaml: () -> void
+  def self?.config: () -> Hash[String, untyped]?
+end

data/sig/vendor/thor.rbs

@@ -0,0 +1,34 @@
+# Minimal Thor stubs for type checking
+class Thor
+  def self.desc: (String usage, String description, ?Hash[Symbol, untyped] options) -> void
+  def self.method_option: (Symbol name, **untyped options) -> void
+  def self.class_option: (Symbol name, **untyped options) -> void
+  def self.option: (Symbol name, **untyped options) -> void
+  def self.map: (Hash[String, Symbol] mappings) -> void
+  def self.subcommand: (String name, Class subcommand_class) -> void
+  def self.no_commands: () { () -> void } -> void
+  def self.start: (?Array[String] args, ?Hash[Symbol, untyped] config) -> void
+  def invoke: (Symbol command, ?Array[untyped]? args, ?Array[String]? flags) -> void
+  def options: () -> Hash[Symbol, untyped]
+  def say: (String message, ?Symbol? color) -> void
+end
+
+class Thor::Group
+  include Thor::Actions
+
+  def self.argument: (Symbol name, **untyped options) -> void
+  def self.source_root: (?String path) -> String
+  def self.source_paths: () -> Array[String]
+  def invoke_all: () -> void
+  def args: () -> Array[String]
+end
+
+module Thor::Actions
+  def template: (String source, ?String destination, **untyped options) -> void
+  def create_file: (String destination, ?String data) -> void
+  def empty_directory: (String destination) -> void
+  def copy_file: (String source, ?String destination) -> void
+  def remove_file: (String path) -> void
+  def destination_root: () -> String
+  def self.included: (Module base) -> void
+end

data/sig/vendor/tty_prompt.rbs

@@ -0,0 +1,15 @@
+# Minimal TTY::Prompt stubs
+module TTY
+  class Prompt
+    def initialize: (**untyped options) -> void
+    def select: (String question, ?Array[String] choices, **untyped options) ?{ (untyped menu) -> void } -> String
+    def multi_select: (String question, ?Array[String] choices, **untyped options) ?{ (untyped menu) -> void } -> Array[String]
+    def ask: (String question, **untyped options) -> String?
+    def yes?: (String question, **untyped options) -> bool
+    def no?: (String question, **untyped options) -> bool
+    def say: (String message) -> void
+    def warn: (String message) -> void
+    def error: (String message) -> void
+    def ok: (String message) -> void
+  end
+end

data/spec/adopter/adopt_menu_spec.rb

@@ -126,51 +126,51 @@ RSpec.describe Adopter::AdoptMenu do
     end
 
     it 'raises on missing target_automation' do
-      expect {
+      expect do
         described_class.validate_params!(source_path: 'x', output_path: 'y')
-      }.to raise_error(ArgumentError, /target_automation/)
+      end.to raise_error(ArgumentError, /target_automation/)
     end
 
     it 'raises on missing target_framework' do
-      expect {
+      expect do
         described_class.validate_params!(source_path: 'x', output_path: 'y', target_automation: 'selenium')
-      }.to raise_error(ArgumentError, /target_framework/)
+      end.to raise_error(ArgumentError, /target_framework/)
     end
 
     it 'raises on invalid target_automation' do
-      expect {
+      expect do
         described_class.validate_params!(
           source_path: 'x', output_path: 'y',
           target_automation: 'appium', target_framework: 'rspec'
         )
-      }.to raise_error(ArgumentError, /target_automation must be/)
+      end.to raise_error(ArgumentError, /target_automation must be/)
     end
 
     it 'raises on invalid target_framework' do
-      expect {
+      expect do
         described_class.validate_params!(
           source_path: 'x', output_path: 'y',
           target_automation: 'selenium', target_framework: 'junit'
         )
-      }.to raise_error(ArgumentError, /target_framework must be/)
+      end.to raise_error(ArgumentError, /target_framework must be/)
     end
 
     it 'accepts valid params without raising' do
-      expect {
+      expect do
         described_class.validate_params!(
           source_path: 'x', output_path: 'y',
           target_automation: 'selenium', target_framework: 'rspec'
         )
-      }.not_to raise_error
+      end.not_to raise_error
     end
 
     it 'accepts capybara as valid automation' do
-      expect {
+      expect do
         described_class.validate_params!(
           source_path: 'x', output_path: 'y',
           target_automation: 'capybara', target_framework: 'minitest'
         )
-      }.not_to raise_error
+      end.not_to raise_error
     end
   end
 end

data/spec/adopter/migration_plan_spec.rb

@@ -32,7 +32,7 @@ RSpec.describe Adopter::MigrationPlan do
   end
 
   describe '#to_h' do
-    it 'serializes all fields' do
+    it 'serializes all fields' do # rubocop:disable RSpec/MultipleExpectations
       hash = plan.to_h
       expect(hash[:source_path]).to eq('/source')
       expect(hash[:output_path]).to eq('/output')

data/spec/adopter/migrator_spec.rb

@@ -231,8 +231,8 @@ RSpec.describe Adopter::Migrator do
           },
           converted_pages: [
             Adopter::ConvertedFile.new(
-              output_path: "/dev/null/impossible/path/file.rb",
-              content: "content",
+              output_path: '/dev/null/impossible/path/file.rb',
+              content: 'content',
               source_file: 'pages/bad.rb',
               conversion_notes: 'Will fail'
             )

data/spec/adopter/project_detector_spec.rb

@@ -76,7 +76,7 @@ RSpec.describe Adopter::ProjectDetector do
       end
     end
 
-    { 'eyes_selenium' => 'applitools', 'axe-core-selenium' => 'axe',
+    { 'eyes_selenium' => 'selenium', 'axe-core-selenium' => 'selenium',
       'capybara' => 'capybara', 'site_prism' => 'capybara' }.each do |gem_name, expected|
       context "with #{gem_name} in Gemfile" do
         before { File.write("#{project_dir}/Gemfile", "gem '#{gem_name}'\n") }

data/spec/commands/raider_commands_spec.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'rspec'
+require_relative '../../lib/ruby_raider'
+
+RSpec.describe RubyRaider::Raider do
+  describe 'new command' do
+    context 'with parameters' do
+      it 'calls InvokeGenerators.generate_framework with parsed hash' do
+        allow(InvokeGenerators).to receive(:generate_framework)
+
+        described_class.new.invoke(:new, nil, %w[my_project -p framework:rspec automation:selenium])
+
+        expect(InvokeGenerators).to have_received(:generate_framework).with(
+          hash_including(framework: 'rspec', automation: 'selenium', name: 'my_project')
+        )
+      end
+    end
+
+    context 'without parameters' do
+      it 'calls MenuGenerator.generate_choice_menu' do
+        menu = instance_double(MenuGenerator, generate_choice_menu: nil)
+        allow(MenuGenerator).to receive(:new).and_return(menu)
+
+        described_class.new.invoke(:new, nil, %w[my_project])
+
+        expect(menu).to have_received(:generate_choice_menu)
+      end
+    end
+  end
+
+  describe 'version command' do
+    it 'outputs the version from lib/version' do
+      expected_version = File.read(File.expand_path('../../lib/version', __dir__)).strip
+      expect { described_class.new.invoke(:version) }.to output(/#{Regexp.escape(expected_version)}/).to_stdout
+    end
+  end
+
+  describe 'subcommand aliases' do
+    it 'maps n to new' do
+      expect(described_class.map['n']).to eq('new')
+    end
+
+    it 'maps v to version' do
+      expect(described_class.map['v']).to eq('version')
+    end
+
+    it 'maps a to adopt' do
+      expect(described_class.map['a']).to eq('adopt')
+    end
+
+    it 'maps g to generate' do
+      expect(described_class.map['g']).to eq('generate')
+    end
+
+    it 'maps u to utility' do
+      expect(described_class.map['u']).to eq('utility')
+    end
+
+    it 'maps pm to plugin_manager' do
+      expect(described_class.map['pm']).to eq('plugin_manager')
+    end
+  end
+
+  describe 'registered subcommands' do
+    let(:subcommands) { described_class.subcommands }
+
+    it 'includes adopt' do
+      expect(subcommands).to include('adopt')
+    end
+
+    it 'includes generate' do
+      expect(subcommands).to include('generate')
+    end
+
+    it 'includes utility' do
+      expect(subcommands).to include('utility')
+    end
+
+    it 'includes plugin_manager' do
+      expect(subcommands).to include('plugin_manager')
+    end
+  end
+end
+
+RSpec.describe AdoptCommands do
+  let(:source_dir) { 'tmp_cmd_adopt_source' }
+  let(:output_dir) { 'tmp_cmd_adopt_output' }
+
+  before do
+    FileUtils.mkdir_p(source_dir)
+    File.write("#{source_dir}/Gemfile", "gem 'rspec'\ngem 'selenium-webdriver'\n")
+    FileUtils.mkdir_p("#{source_dir}/spec")
+  end
+
+  after do
+    FileUtils.rm_rf(source_dir)
+    FileUtils.rm_rf(output_dir)
+  end
+
+  describe 'project command with parameters' do
+    it 'calls AdoptMenu.adopt with parsed params' do
+      result = { plan: double(warnings: [], output_path: output_dir), results: { pages: 0, tests: 0, features: 0, steps: 0, errors: [] } } # rubocop:disable RSpec/VerifiedDoubles
+      allow(Adopter::AdoptMenu).to receive(:adopt).and_return(result)
+
+      expect do
+        described_class.new.invoke(:project, nil, [source_dir, '-p',
+                                                   "output_path:#{output_dir}",
+                                                   'target_automation:selenium',
+                                                   'target_framework:rspec'])
+      end.to output(/Adoption complete/).to_stdout
+
+      expect(Adopter::AdoptMenu).to have_received(:adopt).with(
+        hash_including(source_path: source_dir, target_automation: 'selenium', target_framework: 'rspec')
+      )
+    end
+  end
+
+  describe 'project command without parameters' do
+    it 'calls AdoptMenu#run' do
+      menu = instance_double(Adopter::AdoptMenu, run: nil)
+      allow(Adopter::AdoptMenu).to receive(:new).and_return(menu)
+
+      described_class.new.invoke(:project, nil, [source_dir])
+
+      expect(menu).to have_received(:run)
+    end
+  end
+end

data/spec/generators/generator_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'rspec'
+require_relative '../../lib/generators/generator'
+
+RSpec.describe Generator do
+  describe '#ruby_version' do
+    it 'returns the default version when no ruby_version arg is present' do
+      generator = described_class.new(%w[selenium rspec test_project])
+      expect(generator.ruby_version).to eq('3.4')
+    end
+
+    it 'returns the specified version from args' do
+      generator = described_class.new(%w[selenium rspec test_project ruby_version:3.3])
+      expect(generator.ruby_version).to eq('3.3')
+    end
+
+    it 'handles version with multiple colons gracefully' do
+      generator = described_class.new(%w[selenium rspec test_project ruby_version:3.2])
+      expect(generator.ruby_version).to eq('3.2')
+    end
+  end
+end

data/spec/integration/commands/scaffolding_commands_spec.rb

@@ -63,7 +63,7 @@ describe ScaffoldingCommands do
   context 'with a features folder' do
     let(:new_path) { 'test_folder' }
 
-    path = "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::APPLITOOLS}"
+    path = "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::SELENIUM}"
 
     before do
       Dir.chdir path

data/spec/integration/commands/utility_commands_spec.rb

@@ -43,17 +43,37 @@ describe UtilityCommands do
       expect(config['browser']).to eql ':firefox'
     end
 
-    it 'updates the browser options', skip: 'review browser options method' do
+    it 'updates the browser options' do
       utility.new.invoke(:browser, nil, %w[:firefox --opts headless start-maximized start-fullscreen])
       config = YAML.load_file('config/config.yml')
       expect(config['browser_options']).to eql %w[headless start-maximized start-fullscreen]
     end
   end
 
+  context 'with timeout and viewport commands' do
+    path = "#{FrameworkIndex::RSPEC}_#{AutomationIndex::SELENIUM}"
+
+    before do
+      Dir.chdir path
+    end
+
+    it 'updates the timeout' do
+      utility.new.invoke(:timeout, nil, %w[30])
+      config = YAML.load_file('config/config.yml')
+      expect(config['timeout']).to eq 30
+    end
+
+    it 'updates the viewport' do
+      utility.new.invoke(:viewport, nil, %w[375x812])
+      config = YAML.load_file('config/config.yml')
+      expect(config['viewport']).to eq({ 'width' => 375, 'height' => 812 })
+    end
+  end
+
   context 'with a features folder' do
     let(:new_path) { 'test_folder' }
 
-    path = "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::APPLITOOLS}"
+    path = "#{FrameworkIndex::CUCUMBER}_#{AutomationIndex::SELENIUM}"
 
     before do
       Dir.chdir path
@@ -71,7 +91,7 @@ describe UtilityCommands do
       expect(config['feature_path']).to eql path
     end
 
-    it 'updates only the browser options', skip: 'review browser options method' do
+    it 'updates only the browser options' do
       utility.new.invoke(:browser, nil, %w[:firefox --opts headless])
       config = YAML.load_file('config/config.yml')
       expect(config['browser_options']).to eql %w[headless]