ruby_raider 2.0.0 → 3.0.1

data/lib/adopter/plan_builder.rb

@@ -4,7 +4,6 @@ require_relative 'migration_plan'
 require_relative 'converters/identity_converter'
 
 module Adopter
-  # :reek:TooManyMethods { enabled: false }
   class PlanBuilder
     def initialize(analysis, params)
       @analysis = analysis
@@ -63,7 +62,7 @@ module Adopter
       tests = @analysis[:tests] || []
       return [] if target_cucumber?
 
-      tests.select { |t| t[:type] != :cucumber }.map do |test|
+      tests.reject { |t| t[:type] == :cucumber }.map do |test|
         source_file = File.join(@params[:source_path], test[:path])
         content = File.read(source_file)
         converted = convert_test(content, test)
@@ -87,7 +86,7 @@ module Adopter
 
         ConvertedFile.new(
           output_path: raider_feature_path(feature[:path]),
-          content: content,
+          content:,
           source_file: feature[:path],
           conversion_notes: 'Feature file copied as-is'
         )
@@ -125,7 +124,6 @@ module Adopter
       end
     end
 
-    # :reek:ControlParameter { enabled: false }
     def convert_page_dsl(content, page, source_dsl, target)
       converter = find_page_converter(source_dsl, target)
       if converter
@@ -162,7 +160,6 @@ module Adopter
       end
     end
 
-    # :reek:ControlParameter { enabled: false }
     def convert_test_framework(content, test, source_framework, target)
       converter = find_test_converter(source_framework, target)
       if converter

data/lib/adopter/project_analyzer.rb

@@ -5,7 +5,6 @@ require_relative 'project_detector'
 module Adopter
   class MobileProjectError < StandardError; end
 
-  # :reek:TooManyMethods { enabled: false }
   class ProjectAnalyzer
     KNOWN_FRAMEWORK_GEMS = %w[
       activesupport allure-cucumber allure-rspec allure-minitest allure-ruby-commons
@@ -79,7 +78,6 @@ module Adopter
             'Mobile (Appium) projects cannot be adopted. Only web-based projects are supported.'
     end
 
-    # :reek:FeatureEnvy { enabled: false }
     def discover_pages
       page_path = detect_page_dir
       return [] unless page_path
@@ -115,7 +113,6 @@ module Adopter
       results
     end
 
-    # :reek:FeatureEnvy { enabled: false }
     def discover_helpers
       helper_files = Dir.glob(File.join(@source_path, '**', '*helper*.rb')) +
                      Dir.glob(File.join(@source_path, '**', 'support', '*.rb')) +
@@ -129,7 +126,7 @@ module Adopter
 
         {
           path: relative_path(file),
-          role: role,
+          role:,
           modules_defined: extract_modules(content)
         }
       end
@@ -153,7 +150,6 @@ module Adopter
       end
     end
 
-    # :reek:NestedIterators { enabled: false }
     def discover_custom_gems
       gemfile = File.join(@source_path, 'Gemfile')
       return [] unless File.exist?(gemfile)

data/lib/adopter/project_detector.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 module Adopter
-  # :reek:TooManyMethods { enabled: false }
   module ProjectDetector
     GEM_AUTOMATION_MAP = {
       'site_prism' => 'capybara',
@@ -9,9 +8,9 @@ module Adopter
       'selenium-webdriver' => 'selenium',
       'watir' => 'watir',
       'appium_lib' => 'appium',
-      'eyes_selenium' => 'applitools',
-      'axe-core-selenium' => 'axe',
-      'axe-core-rspec' => 'axe'
+      'eyes_selenium' => 'selenium',
+      'axe-core-selenium' => 'selenium',
+      'axe-core-rspec' => 'selenium'
     }.freeze
 
     GEM_FRAMEWORK_MAP = {
@@ -78,7 +77,6 @@ module Adopter
       find_existing_dir(path, candidates)
     end
 
-    # :reek:NestedIterators { enabled: false }
     def detect_browser(path)
       config_files = helper_and_config_files(path)
       config_files.each do |file|

data/lib/commands/adopt_commands.rb

@@ -3,7 +3,6 @@
 require 'thor'
 require_relative '../adopter/adopt_menu'
 
-# :reek:FeatureEnvy { enabled: false }
 class AdoptCommands < Thor
   desc 'project [SOURCE_PATH]', 'Adopts an existing test project into Ruby Raider conventions'
   option :parameters,

data/lib/commands/plugin_commands.rb

@@ -4,8 +4,6 @@ require 'thor'
 require_relative '../plugin/plugin'
 
 module RubyRaider
-  # :reek:FeatureEnvy { enabled: false }
-  # :reek:UtilityFunction { enabled: false }
   class PluginCommands < Thor
     desc 'add [NAME]', 'Adds a plugin to your project'
 

data/lib/commands/scaffolding_commands.rb

@@ -1,100 +1,308 @@
 # frozen_string_literal: true
 
 require 'thor'
+require 'fileutils'
+require 'pathname'
 require_relative '../generators/menu_generator'
 require_relative '../scaffolding/scaffolding'
+require_relative '../scaffolding/name_normalizer'
+require_relative '../scaffolding/dry_run_presenter'
+require_relative '../scaffolding/project_detector'
 require_relative '../commands/utility_commands'
 
-# :reek:FeatureEnvy { enabled: false }
-# :reek:UtilityFunction { enabled: false }
-# :reek:RepeatedConditional { enabled: false }
 class ScaffoldingCommands < Thor
+  class_option :dry_run, type: :boolean, default: false,
+                         desc: 'Preview files without creating them', banner: ''
+
   desc 'page [PAGE_NAME]', 'Creates a new page object'
-  option :path,
-         type: :string, required: false, desc: 'The path where your page will be created', aliases: '-p'
-  option :delete,
-         type: :boolean, required: false, desc: 'This will delete the selected page', aliases: '-d'
+  option :path, type: :string, required: false,
+                desc: 'The path where your page will be created', aliases: '-p'
+  option :delete, type: :boolean, required: false,
+                  desc: 'This will delete the selected page', aliases: '-d'
+  option :uses, type: :array, required: false,
+                desc: 'Dependent pages to require', aliases: '-u'
 
   def page(name)
     return delete_scaffolding(name, 'page') if options[:delete]
+    return dry_run_preview(name, 'page') if options[:dry_run]
 
-    generate_scaffolding(name, 'page', options[:path])
+    generate_scaffolding(name, 'page', options[:path], uses: options[:uses])
   end
 
   desc 'feature [NAME]', 'Creates a new feature'
-  option :path,
-         type: :string,
-         required: false, desc: 'The path where your feature will be created', aliases: '-p'
-  option :delete,
-         type: :boolean,
-         required: false, desc: 'This will delete the selected feature', aliases: '-d'
+  option :path, type: :string, required: false,
+                desc: 'The path where your feature will be created', aliases: '-p'
+  option :delete, type: :boolean, required: false,
+                  desc: 'This will delete the selected feature', aliases: '-d'
 
   def feature(name)
     return delete_scaffolding(name, 'feature') if options[:delete]
+    return dry_run_preview(name, 'feature') if options[:dry_run]
 
     generate_scaffolding(name, 'feature', options[:path])
   end
 
   desc 'spec [SPEC_NAME]', 'Creates a new spec'
-  option :path,
-         type: :string, required: false, desc: 'The path where your spec will be created', aliases: '-p'
-  option :delete,
-         type: :boolean, required: false, desc: 'This will delete the selected spec', aliases: '-d'
+  option :path, type: :string, required: false,
+                desc: 'The path where your spec will be created', aliases: '-p'
+  option :delete, type: :boolean, required: false,
+                  desc: 'This will delete the selected spec', aliases: '-d'
+  option :from, type: :string, required: false,
+                desc: 'Generate spec stubs from an existing page object file', aliases: '-f'
+  option :uses, type: :array, required: false,
+                desc: 'Dependent pages to require', aliases: '-u'
+  option :ai, type: :boolean, default: false,
+              desc: 'Use LLM to generate meaningful test scenarios'
 
   def spec(name)
     return delete_scaffolding(name, 'spec') if options[:delete]
+    return dry_run_preview(name, 'spec') if options[:dry_run]
+    return generate_spec_from_page(name, options[:from], ai: options[:ai]) if options[:from]
 
-    generate_scaffolding(name, 'spec', options[:path])
+    generate_scaffolding(name, 'spec', options[:path], uses: options[:uses])
   end
 
   desc 'helper [HELPER_NAME]', 'Creates a new helper'
-  option :path,
-         type: :string, required: false, desc: 'The path where your helper will be created', aliases: '-p'
-  option :delete,
-         type: :boolean, required: false, desc: 'This will delete the selected helper', aliases: '-d'
+  option :path, type: :string, required: false,
+                desc: 'The path where your helper will be created', aliases: '-p'
+  option :delete, type: :boolean, required: false,
+                  desc: 'This will delete the selected helper', aliases: '-d'
 
   def helper(name)
     return delete_scaffolding(name, 'helper') if options[:delete]
+    return dry_run_preview(name, 'helper') if options[:dry_run]
 
     generate_scaffolding(name, 'helper', options[:path])
   end
 
   desc 'steps [STEPS_NAME]', 'Creates a new steps definition'
-  option :path,
-         type: :string, required: false, desc: 'The path where your steps will be created', aliases: '-p'
-  option :delete,
-         type: :boolean, required: false, desc: 'This will delete the selected steps', aliases: '-d'
+  option :path, type: :string, required: false,
+                desc: 'The path where your steps will be created', aliases: '-p'
+  option :delete, type: :boolean, required: false,
+                  desc: 'This will delete the selected steps', aliases: '-d'
 
   def steps(name)
     return delete_scaffolding(name, 'steps') if options[:delete]
+    return dry_run_preview(name, 'steps') if options[:dry_run]
 
     generate_scaffolding(name, 'steps', options[:path])
   end
 
-  desc 'scaffold [SCAFFOLD_NAME]', 'It generates everything needed to start automating'
+  desc 'component [NAME]', 'Creates a component inheriting from Component'
+  option :path, type: :string, required: false,
+                desc: 'The path where your component will be created', aliases: '-p'
+  option :delete, type: :boolean, required: false,
+                  desc: 'This will delete the selected component', aliases: '-d'
+
+  def component(name)
+    return delete_scaffolding(name, 'component') if options[:delete]
+    return dry_run_preview(name, 'component') if options[:dry_run]
+
+    generate_scaffolding(name, 'component', options[:path])
+  end
+
+  desc 'scaffold [NAMES...]', 'Generates pages, specs/features, and helpers for one or more names'
+  option :with, type: :array, required: false,
+                desc: 'Components to generate (page,spec,feature,steps,helper,component,model)', aliases: '-w'
+  option :crud, type: :boolean, required: false,
+                desc: 'Generate CRUD pages (list, create, detail, edit) + tests + model'
+  option :uses, type: :array, required: false,
+                desc: 'Dependent pages to require', aliases: '-u'
+
+  def scaffold(*names)
+    return interactive_scaffold if names.empty?
+
+    names.each do |name|
+      if options[:crud]
+        generate_crud(name)
+      elsif options[:with]
+        generate_selected_components(name, options[:with])
+      else
+        generate_default_scaffold(name)
+      end
+    end
+  end
+
+  desc 'destroy [NAMES...]', 'Removes all scaffolded files for the given names (page, spec/feature, steps)'
+  option :with, type: :array, required: false,
+                desc: 'Components to destroy (page,spec,feature,steps,helper,component)', aliases: '-w'
+
+  def destroy(*names)
+    if names.empty?
+      say 'Please provide at least one name to destroy', :red
+      return
+    end
+
+    names.each { |name| destroy_scaffold(name, options[:with]) }
+  end
+
+  map 'd' => 'destroy'
+
+  desc 'from_url [URL]', 'Generates page object and spec from a live URL'
+  option :name, type: :string, required: false,
+                desc: 'Override the page object name', aliases: '-n'
+  option :ai, type: :boolean, default: false,
+              desc: 'Use LLM for intelligent page analysis'
+
+  def from_url(url)
+    require_relative '../scaffolding/url_analyzer'
+    analyzer = UrlAnalyzer.new(url, name_override: options[:name], ai: options[:ai])
+    analysis = analyzer.analyze.to_h
+
+    page_name = analysis[:page_name]
 
-  def scaffold(name)
-    if Pathname.new('spec').exist? && !Pathname.new('features').exist?
-      Scaffolding.new([name, load_config_path('spec')]).generate_spec
-    else
-      Scaffolding.new([name, load_config_path('feature')]).generate_feature
-      Scaffolding.new([name, load_config_path('steps')]).generate_steps
+    if options[:dry_run]
+      DryRunPresenter.preview([
+                                "page_objects/pages/#{page_name}.rb",
+                                "spec/#{page_name}_spec.rb"
+                              ])
+      return
     end
-    Scaffolding.new([name, load_config_path('page')]).generate_page
+
+    Scaffolding.new([page_name]).generate_page_from_url(analysis)
+    Scaffolding.new([page_name]).generate_spec_from_url(analysis)
+    say "Generated page object and spec for #{url}"
   end
 
   no_commands do
     def load_config_path(type)
-      YAML.load_file('config/config.yml')["#{type}_path"] if Pathname.new('config/config.yml').exist?
+      ScaffoldProjectDetector.config_path(type)
+    end
+
+    def validate_project!
+      warnings = ScaffoldProjectDetector.validate_project
+      warnings.each { |w| say "Warning: #{w}", :yellow }
+      show_detection_defaults
+    end
+
+    def show_detection_defaults
+      gemfile = ScaffoldProjectDetector.read_gemfile
+      if gemfile.empty?
+        say 'Warning: No Gemfile found, defaulting to selenium + rspec templates.', :yellow
+      else
+        automation = ScaffoldProjectDetector.detect_automation(gemfile)
+        framework = ScaffoldProjectDetector.detect_framework(gemfile)
+        if automation.nil?
+          say 'Warning: Could not detect automation library from Gemfile, defaulting to selenium.', :yellow
+        end
+        say 'Warning: Could not detect test framework from Gemfile, defaulting to rspec.', :yellow if framework.nil?
+      end
     end
 
     def delete_scaffolding(name, type)
       Scaffolding.new([name]).send("delete_#{type}")
     end
 
-    def generate_scaffolding(name, type, path)
+    def generate_scaffolding(name, type, path, uses: nil)
       path ||= load_config_path(type)
-      Scaffolding.new([name, path]).send("generate_#{type}")
+      scaffolding = Scaffolding.new([name, path])
+      scaffolding.uses = Array(uses) if uses
+      scaffolding.send("generate_#{type}")
+    end
+
+    def dry_run_preview(name, type)
+      path = options[:path] || load_config_path(type)
+      file = Scaffolding.planned_path(name, type, path)
+      DryRunPresenter.preview([file])
+    end
+
+    def generate_default_scaffold(name)
+      validate_project!
+      uses = options[:uses]
+      if Pathname.new('spec').exist? && !Pathname.new('features').exist?
+        generate_scaffolding(name, 'spec', load_config_path('spec'), uses:)
+      else
+        generate_scaffolding(name, 'feature', load_config_path('feature'))
+        generate_scaffolding(name, 'steps', load_config_path('steps'), uses:)
+      end
+      generate_scaffolding(name, 'page', load_config_path('page'), uses:)
+    end
+
+    def generate_selected_components(name, components)
+      validate_project!
+      uses = options[:uses]
+      components.each do |comp|
+        comp = comp.downcase.strip
+        case comp
+        when 'model'
+          generate_model_data(name)
+        else
+          generate_scaffolding(name, comp, load_config_path(comp), uses:)
+        end
+      end
+    end
+
+    def generate_crud(name)
+      require_relative '../scaffolding/crud_generator'
+      validate_project!
+      if options[:dry_run]
+        crud = CrudGenerator.new(name, Scaffolding, method(:load_config_path))
+        DryRunPresenter.preview(crud.planned_files)
+        return
+      end
+      crud = CrudGenerator.new(name, Scaffolding, method(:load_config_path))
+      generated = crud.generate
+      say "Generated CRUD scaffold for: #{generated.join(', ')}"
+    end
+
+    def generate_spec_from_page(name, source_file, ai: false) # rubocop:disable Naming/MethodParameterName
+      Scaffolding.new([name]).generate_spec_from_page(source_file, ai:)
+    end
+
+    def generate_model_data(name)
+      normalized = NameNormalizer.normalize(name)
+      path = "models/data/#{normalized}.yml"
+      return if File.exist?(path)
+
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, model_template(normalized))
+    end
+
+    def model_template(name)
+      <<~YAML
+        # Data model for #{name}
+        default:
+          name: 'Test #{name.capitalize}'
+          email: 'test@example.com'
+
+        valid:
+          name: 'Valid #{name.capitalize}'
+          email: 'valid@example.com'
+
+        invalid:
+          name: ''
+          email: 'invalid'
+      YAML
+    end
+
+    def destroy_scaffold(name, components = nil)
+      types = components ? components.map { |c| c.downcase.strip } : detect_scaffold_types
+      types.each { |type| delete_scaffolding(name, type) }
+    end
+
+    def detect_scaffold_types
+      if Pathname.new('spec').exist? && !Pathname.new('features').exist?
+        %w[page spec]
+      else
+        %w[page feature steps]
+      end
+    end
+
+    def interactive_scaffold
+      require_relative '../scaffolding/scaffold_menu'
+      validate_project!
+      result = ScaffoldMenu.new.run
+      return unless result
+
+      result[:names].each do |name|
+        result[:components].each do |comp|
+          if comp == :model
+            generate_model_data(name)
+          else
+            generate_scaffolding(name, comp.to_s, load_config_path(comp.to_s), uses: result[:uses])
+          end
+        end
+      end
     end
   end
 end

data/lib/commands/utility_commands.rb

@@ -3,8 +3,6 @@
 require 'thor'
 require_relative '../utilities/utilities'
 
-# :reek:FeatureEnvy { enabled: false }
-# :reek:UtilityFunction { enabled: false }
 class UtilityCommands < Thor
   desc 'path [PATH]', 'Sets the default path for scaffolding'
   option :feature,
@@ -37,7 +35,7 @@ class UtilityCommands < Thor
     browser_options(selected_options) if selected_options || options[:delete]
   end
 
-  desc 'browser_options [OPTIONS]', 'Sets the browser options for the project'
+  desc 'browser_options [OPTIONS]', 'Sets the browser arguments for the current browser (e.g. no-sandbox, headless)'
   option :delete,
          type: :boolean, required: false, desc: 'This will delete your browser options', aliases: '-d'
 
@@ -46,6 +44,15 @@ class UtilityCommands < Thor
     Utilities.delete_browser_options if options[:delete]
   end
 
+  desc 'headless [on/off]', 'Toggles headless mode for browser tests'
+
+  def headless(toggle)
+    enabled = %w[on true 1 yes].include?(toggle.downcase)
+    Utilities.headless = enabled
+    state = enabled ? 'enabled' : 'disabled'
+    say "Headless mode #{state}", :green
+  end
+
   desc 'raid', 'It runs all the tests in a project'
   option :parallel,
          type: :boolean, required: false, desc: 'It runs the tests in parallel', aliases: '-p'
@@ -67,14 +74,96 @@ class UtilityCommands < Thor
   option :delete,
          type: :boolean, required: false, desc: 'This will delete the selected config file', aliases: '-d'
 
+  desc 'timeout [SECONDS]', 'Sets the default test timeout in seconds'
+
+  def timeout(seconds)
+    Utilities.timeout = seconds
+  end
+
+  desc 'viewport [DIMENSIONS]', 'Sets the default viewport size (e.g. 1920x1080, 375x812)'
+
+  def viewport(dimensions)
+    Utilities.viewport = dimensions
+  end
+
   desc 'platform [PLATFORM]', 'Sets the default platform for a cross-platform project'
 
   def platform(platform)
     Utilities.platform = platform
   end
 
+  desc 'debug [on/off]', 'Toggles debug mode for failure diagnostics and logging'
+
+  def debug(toggle)
+    enabled = %w[on true 1 yes].include?(toggle.downcase)
+    Utilities.debug = enabled
+    state = enabled ? 'enabled' : 'disabled'
+    say "Debug mode #{state}", :green
+  end
+
   desc 'start_appium', 'It starts the appium server'
   def start_appium
     system 'appium  --base-path /wd/hub'
   end
+
+  desc 'desktop', 'Downloads the Raider Desktop GUI application'
+  option :path, type: :string, required: false,
+                desc: 'Directory to save the download', aliases: '-p'
+
+  def desktop
+    require_relative '../utilities/desktop_downloader'
+    version = DesktopDownloader.latest_version
+    unless version
+      say 'Could not reach GitHub releases. Check your internet connection.', :red
+      return
+    end
+
+    say "Raider Desktop v#{version} available for #{DesktopDownloader.platform_display_name}"
+    DesktopDownloader.download(options[:path])
+    say 'Raider Desktop downloaded successfully!', :green
+  end
+
+  desc 'llm [PROVIDER]', 'Configures the LLM provider (openai, anthropic, ollama)'
+  option :key, type: :string, required: false, desc: 'API key for the provider', aliases: '-k'
+  option :model, type: :string, required: false, desc: 'Model name to use', aliases: '-m'
+  option :url, type: :string, required: false, desc: 'API URL (for ollama)', aliases: '-u'
+  option :status, type: :boolean, required: false, desc: 'Show current LLM configuration', aliases: '-s'
+
+  def llm(provider = nil)
+    if options[:status] || provider.nil?
+      show_llm_status
+      return
+    end
+    configure_llm(provider)
+  end
+
+  no_commands do
+    def configure_llm(provider)
+      unless %w[openai anthropic ollama].include?(provider)
+        say "Unknown provider '#{provider}'. Choose: openai, anthropic, ollama", :red
+        return
+      end
+
+      Utilities.llm_provider = provider
+      Utilities.llm_api_key = options[:key] if options[:key]
+      Utilities.llm_model = options[:model] if options[:model]
+      Utilities.llm_url = options[:url] if options[:url]
+      say "LLM configured: #{provider}", :green
+    end
+
+    def show_llm_status
+      require_relative '../llm/client'
+      status = Llm::Client.status
+      if status[:configured]
+        say "Provider: #{status[:provider]}"
+        say "Model: #{status[:model] || 'default'}"
+        say "Available: #{status[:available] ? 'yes' : 'no'}"
+      else
+        say 'No LLM configured. Use: raider u llm <provider>', :yellow
+        say '  Providers: openai, anthropic, ollama'
+        say '  Example:   raider u llm ollama'
+        say '  Example:   raider u llm openai -k sk-...'
+      end
+    end
+  end
 end

data/lib/generators/automation/automation_generator.rb

@@ -9,7 +9,6 @@ class AutomationGenerator < Generator
       generate_home_page
       generate_pdp_page
     else
-      generate_visual_options
       generate_components
       generate_model_files
       generate_pages
@@ -47,12 +46,6 @@ class AutomationGenerator < Generator
     template('appium_caps.tt', "#{name}/config/capabilities.yml")
   end
 
-  def generate_visual_options
-    return unless visual?
-
-    template('visual_options.tt', "#{name}/config/options.yml")
-  end
-
   def generate_login_page
     template('login.tt', "#{name}/page_objects/pages/login.rb")
   end

data/lib/generators/automation/templates/partials/element.tt

@@ -1,4 +1,4 @@
-<% if %w[selenium axe applitools appium_ios appium_android].include?(automation) -%>
+<% if %w[selenium appium_ios appium_android].include?(automation) -%>
   driver.find_element
 <% else -%>
   browser.element

data/lib/generators/automation/templates/partials/initialize_selector.tt

@@ -6,13 +6,6 @@
   def initialize(browser)
     @browser = browser
   end
-<% elsif axe? %>
-  attr_reader :driver
-  alias page driver
-
-  def initialize(driver)
-    @driver = driver
-  end
 <% else %>
   attr_reader :driver
 

data/lib/generators/automation/templates/partials/url_methods.tt

@@ -3,7 +3,6 @@
     "#{base_url}#{url(*page)}"
   end
 
-  # :reek:UtilityFunction
   def base_url
     YAML.load_file('config/config.yml')['url']
   end