ruby_raider 1.1.4 → 3.0.0

data/lib/adopter/project_detector.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Adopter
+  module ProjectDetector
+    GEM_AUTOMATION_MAP = {
+      'site_prism' => 'capybara',
+      'capybara' => 'capybara',
+      'selenium-webdriver' => 'selenium',
+      'watir' => 'watir',
+      'appium_lib' => 'appium',
+      'eyes_selenium' => 'selenium',
+      'axe-core-selenium' => 'selenium',
+      'axe-core-rspec' => 'selenium'
+    }.freeze
+
+    GEM_FRAMEWORK_MAP = {
+      'cucumber' => 'cucumber',
+      'rspec' => 'rspec',
+      'minitest' => 'minitest'
+    }.freeze
+
+    BROWSERS = %w[chrome firefox safari edge].freeze
+
+    module_function
+
+    def detect(path = '.')
+      {
+        automation: detect_automation(path),
+        framework: detect_framework(path),
+        page_path: detect_page_path(path),
+        spec_path: detect_spec_path(path),
+        feature_path: detect_feature_path(path),
+        helper_path: detect_helper_path(path),
+        browser: detect_browser(path),
+        url: detect_url(path),
+        ci_platform: detect_ci_platform(path)
+      }.compact
+    end
+
+    def detect_automation(path)
+      gems = parse_gemfile(path)
+      GEM_AUTOMATION_MAP.each do |gem_name, automation|
+        return automation if gems.include?(gem_name)
+      end
+      detect_automation_from_requires(path)
+    end
+
+    def detect_framework(path)
+      gems = parse_gemfile(path)
+      GEM_FRAMEWORK_MAP.each do |gem_name, framework|
+        return framework if gems.include?(gem_name)
+      end
+      return 'rspec' if Dir.exist?(File.join(path, 'spec'))
+      return 'cucumber' if Dir.exist?(File.join(path, 'features'))
+      return 'minitest' if Dir.exist?(File.join(path, 'test'))
+
+      nil
+    end
+
+    def detect_page_path(path)
+      candidates = %w[page_objects/pages page_objects pages page]
+      find_existing_dir(path, candidates)
+    end
+
+    def detect_spec_path(path)
+      candidates = %w[spec spec/features spec/tests test tests]
+      find_existing_dir(path, candidates)
+    end
+
+    def detect_feature_path(path)
+      candidates = %w[features features/scenarios]
+      find_existing_dir(path, candidates)
+    end
+
+    def detect_helper_path(path)
+      candidates = %w[helpers support spec/support features/support]
+      find_existing_dir(path, candidates)
+    end
+
+    def detect_browser(path)
+      config_files = helper_and_config_files(path)
+      config_files.each do |file|
+        next unless File.exist?(file)
+
+        content = File.read(file)
+        BROWSERS.each do |browser|
+          return browser if content.match?(/(?:browser|driver)\s*[:=]\s*[:'"]?#{browser}\b/i)
+        end
+      end
+      nil
+    end
+
+    def detect_url(path)
+      config_files = helper_and_config_files(path)
+      config_files.each do |file|
+        next unless File.exist?(file)
+
+        content = File.read(file)
+        match = content.match(%r{(?:base_url|url|app_host)\s*[:=]\s*['"]?(https?://[^\s'"]+)})
+        return match[1] if match
+      end
+      nil
+    end
+
+    def detect_ci_platform(path)
+      return 'github' if Dir.exist?(File.join(path, '.github', 'workflows'))
+      return 'gitlab' if File.exist?(File.join(path, '.gitlab-ci.yml'))
+
+      nil
+    end
+
+    def parse_gemfile(path)
+      gemfile = File.join(path, 'Gemfile')
+      return [] unless File.exist?(gemfile)
+
+      File.readlines(gemfile).filter_map do |line|
+        match = line.match(/^\s*gem\s+['"]([^'"]+)['"]/)
+        match[1] if match
+      end
+    end
+
+    def detect_automation_from_requires(path)
+      ruby_files = Dir.glob(File.join(path, '**', '*.rb'))
+      ruby_files.first(50).each do |file|
+        content = File.read(file)
+        return 'capybara' if content.include?("require 'capybara'") || content.include?("require 'site_prism'")
+        return 'selenium' if content.include?("require 'selenium-webdriver'")
+        return 'watir' if content.include?("require 'watir'")
+        return 'appium' if content.include?("require 'appium_lib'")
+      end
+      nil
+    end
+
+    def find_existing_dir(path, candidates)
+      candidates.each do |candidate|
+        return candidate if Dir.exist?(File.join(path, candidate))
+      end
+      nil
+    end
+
+    def helper_and_config_files(path)
+      explicit = [
+        File.join(path, 'config', 'config.yml'),
+        File.join(path, 'spec', 'spec_helper.rb'),
+        File.join(path, 'test', 'test_helper.rb'),
+        File.join(path, 'features', 'support', 'env.rb'),
+        File.join(path, 'support', 'env.rb'),
+        File.join(path, '.env')
+      ]
+      helpers = Dir.glob(File.join(path, '**', '*helper*.rb')).first(10)
+      explicit + helpers
+    end
+
+    private_class_method :detect_automation_from_requires, :find_existing_dir,
+                         :helper_and_config_files, :parse_gemfile
+  end
+end

data/lib/commands/adopt_commands.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'thor'
+require_relative '../adopter/adopt_menu'
+
+class AdoptCommands < Thor
+  desc 'project [SOURCE_PATH]', 'Adopts an existing test project into Ruby Raider conventions'
+  option :parameters,
+         type: :hash, required: false,
+         desc: 'Parameters to bypass the menu (output_path, target_automation, target_framework, ci_platform)',
+         aliases: 'p'
+
+  def project(source_path)
+    params = options[:parameters]
+    if params
+      parsed = params.transform_keys(&:to_sym)
+      parsed[:source_path] = source_path
+      result = Adopter::AdoptMenu.adopt(parsed)
+      print_programmatic_results(result)
+    else
+      Adopter::AdoptMenu.new.run
+    end
+  rescue Adopter::MobileProjectError => e
+    puts "Error: #{e.message}"
+    exit 1
+  rescue ArgumentError => e
+    puts "Invalid parameters: #{e.message}"
+    exit 1
+  end
+
+  private
+
+  def print_programmatic_results(result)
+    plan = result[:plan]
+    results = result[:results]
+    puts "Adoption complete: #{results[:pages]} pages, #{results[:tests]} tests, " \
+         "#{results[:features]} features, #{results[:steps]} steps"
+    puts "Warnings: #{plan.warnings.join('; ')}" unless plan.warnings.empty?
+    puts "Errors: #{results[:errors].join('; ')}" unless results[:errors].empty?
+    puts "Output: #{plan.output_path}"
+  end
+end

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,86 +1,166 @@
 # frozen_string_literal: true
 
 require 'thor'
+require 'fileutils'
 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
 
-  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
+    page_name = analysis[:page_name]
+
+    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
@@ -92,9 +172,112 @@ class ScaffoldingCommands < Thor
       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)
+      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)
+      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'
+      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'
+      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,
@@ -67,14 +65,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/account.tt

@@ -1,5 +1,9 @@
-<%- if selenium_based? -%>
-<%=- ERB.new(File.read(File.expand_path('./partials/selenium_account.tt', __dir__)), trim_mode: '-').result(binding) -%>
-<%- elsif watir? -%>
-<%=- ERB.new(File.read(File.expand_path('./partials/watir_account.tt', __dir__)), trim_mode: '-').result(binding) -%>
-<%- end -%>
+# frozen_string_literal: true
+
+require_relative '../abstract/page'
+
+class Account < Page
+  def url(_page)
+    'index.php?rt=account/account'
+  end
+end