ruby_raider 2.0.0 → 3.0.1

data/lib/ruby_raider.rb

@@ -1,21 +1,24 @@
 # frozen_string_literal: true
 
-require_relative '../lib/plugin/plugin'
-require_relative '../lib/commands/plugin_commands'
-require_relative '../lib/commands/loaded_commands'
-require_relative '../lib/commands/adopt_commands'
-require_relative '../lib/commands/scaffolding_commands'
-require_relative '../lib/commands/utility_commands'
-
-# :reek:FeatureEnvy { enabled: false }
-# :reek:UtilityFunction { enabled: false }
+require 'thor'
+
+# Lazy-load top-level command classes to reduce CLI startup time.
+autoload :AdoptCommands, File.expand_path('commands/adopt_commands', __dir__)
+autoload :ScaffoldingCommands, File.expand_path('commands/scaffolding_commands', __dir__)
+autoload :UtilityCommands, File.expand_path('commands/utility_commands', __dir__)
+
 module RubyRaider
+  # Lazy-load namespaced classes within the correct module scope.
+  autoload :Plugin, File.expand_path('plugin/plugin', __dir__)
+  autoload :PluginCommands, File.expand_path('commands/plugin_commands', __dir__)
+  autoload :LoadedCommands, File.expand_path('commands/loaded_commands', __dir__)
+
   class Raider < Thor
     no_tasks do
       def self.plugin_commands?
-        File.readlines(File.expand_path('commands/loaded_commands.rb', __dir__)).any? do |line|
-          line.include?('subcommand')
-        end
+        @plugin_commands ||= File.read(
+          File.expand_path('commands/loaded_commands.rb', __dir__)
+        ).include?('subcommand')
       end
 
       def current_version = File.read(File.expand_path('version', __dir__)).strip
@@ -24,12 +27,31 @@ module RubyRaider
     desc 'new [PROJECT_NAME]', 'Creates a new framework based on settings picked'
     option :parameters,
            type: :hash, required: false, desc: 'Parameters to avoid using the menu', aliases: 'p'
+    option :skip_ci,
+           type: :boolean, required: false, desc: 'Skip CI/CD configuration generation'
+    option :skip_allure,
+           type: :boolean, required: false, desc: 'Skip Allure reporting setup'
+    option :skip_video,
+           type: :boolean, required: false, desc: 'Skip video recording setup'
+    option :reporter,
+           type: :string, required: false, desc: 'Reporter: allure, junit, json, both, all, none', aliases: '-r'
+    option :accessibility,
+           type: :boolean, required: false, desc: 'Add axe accessibility testing'
+    option :visual,
+           type: :boolean, required: false, desc: 'Add visual regression testing'
+    option :performance,
+           type: :boolean, required: false, desc: 'Add Lighthouse performance auditing'
+    option :ruby_version,
+           type: :string, required: false, desc: 'Ruby version for generated project (e.g. 3.4, 3.3)'
 
     def new(project_name)
+      require_relative 'utilities/logo'
+      RubyRaider::Logo.display
       params = options[:parameters]
       if params
         params[:name] = project_name
         parsed_hash = params.transform_keys(&:to_sym)
+        merge_skip_flags(parsed_hash)
         return InvokeGenerators.generate_framework(parsed_hash)
       end
 
@@ -67,5 +89,18 @@ module RubyRaider
       subcommand 'plugins', LoadedCommands
       map 'ps' => 'plugins'
     end
+
+    no_tasks do
+      def merge_skip_flags(params)
+        %i[skip_ci skip_allure skip_video].each do |flag|
+          params[flag] = true if options[flag]
+        end
+        params[:reporter] = options[:reporter] if options[:reporter]
+        params[:accessibility] = true if options[:accessibility]
+        params[:visual] = true if options[:visual]
+        params[:performance] = true if options[:performance]
+        params[:ruby_version] = options[:ruby_version] if options[:ruby_version]
+      end
+    end
   end
 end

data/lib/scaffolding/crud_generator.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative 'name_normalizer'
+
+class CrudGenerator
+  ACTIONS = %w[list create detail edit].freeze
+
+  def initialize(base_name, scaffolding_class, config_loader)
+    @base_name = NameNormalizer.normalize(base_name)
+    @scaffolding_class = scaffolding_class
+    @config_loader = config_loader
+  end
+
+  def generate
+    generated = []
+    ACTIONS.each do |action|
+      name = "#{@base_name}_#{action}"
+      generate_page(name)
+      generate_test(name)
+      generated << name
+    end
+    generate_model
+    generated
+  end
+
+  def planned_files
+    files = []
+    ACTIONS.each do |action|
+      name = "#{@base_name}_#{action}"
+      files << "page_objects/pages/#{name}.rb"
+      files << test_path(name)
+    end
+    files << "models/data/#{@base_name}.yml"
+    files
+  end
+
+  private
+
+  def generate_page(name)
+    path = @config_loader.call('page')
+    @scaffolding_class.new([name, path]).generate_page
+  end
+
+  def generate_test(name)
+    if Dir.exist?('features')
+      path = @config_loader.call('feature')
+      @scaffolding_class.new([name, path]).generate_feature
+      path = @config_loader.call('steps')
+      @scaffolding_class.new([name, path]).generate_steps
+    elsif Dir.exist?('test')
+      path = @config_loader.call('spec')
+      @scaffolding_class.new([name, path]).generate_spec
+    else
+      path = @config_loader.call('spec')
+      @scaffolding_class.new([name, path]).generate_spec
+    end
+  end
+
+  def generate_model
+    model_path = "models/data/#{@base_name}.yml"
+    return if File.exist?(model_path)
+
+    FileUtils.mkdir_p(File.dirname(model_path))
+    File.write(model_path, model_content)
+  end
+
+  def model_content
+    <<~YAML
+      # Data model for #{@base_name}
+      # Used with ModelFactory for test data generation
+      default:
+        name: 'Test #{@base_name.capitalize}'
+        email: 'test@example.com'
+
+      valid:
+        name: 'Valid #{@base_name.capitalize}'
+        email: 'valid@example.com'
+
+      invalid:
+        name: ''
+        email: 'invalid'
+    YAML
+  end
+
+  def test_path(name)
+    if Dir.exist?('features')
+      "features/#{name}.feature"
+    elsif Dir.exist?('test')
+      "test/test_#{name}.rb"
+    else
+      "spec/#{name}_page_spec.rb"
+    end
+  end
+end

data/lib/scaffolding/dry_run_presenter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module DryRunPresenter
+  module_function
+
+  def preview(planned_files)
+    return [] if planned_files.empty?
+
+    puts '[dry-run] Would create:'
+    planned_files.each do |file|
+      puts "  #{file}"
+    end
+    puts ''
+    planned_files
+  end
+end

data/lib/scaffolding/name_normalizer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module NameNormalizer
+  SUFFIXES = %w[_page _spec _steps _helper _test _feature].freeze
+
+  module_function
+
+  # Normalize raw user input to a clean base name
+  # 'LoginPage' -> 'login', 'login_page' -> 'login', 'admin/users' -> 'admin/users'
+  def normalize(input)
+    name = input.to_s.strip
+    name = camel_to_snake(name) if name.match?(/[A-Z]/)
+    strip_suffixes(name)
+  end
+
+  # Convert to class name: 'login' -> 'LoginPage', 'admin/users' -> 'Admin::UsersPage'
+  def to_class_name(input, suffix = '')
+    normalized = normalize(input)
+    parts = normalized.split('/')
+    parts.map { |part| part.split('_').map(&:capitalize).join }.join('::') + suffix
+  end
+
+  # Convert to page class: 'login' -> 'LoginPage'
+  def to_page_class(input)
+    to_class_name(input, 'Page')
+  end
+
+  # Convert to file name: 'LoginPage' -> 'login', 'admin/users' -> 'admin/users'
+  def to_file_name(input)
+    normalize(input)
+  end
+
+  # Check if the input contains a nested path
+  def nested?(input)
+    normalize(input).include?('/')
+  end
+
+  # Get the module path for nested names: 'admin/users' -> ['Admin']
+  def module_parts(input)
+    parts = normalize(input).split('/')
+    parts[0..-2].map { |p| p.split('_').map(&:capitalize).join }
+  end
+
+  # Get the leaf name: 'admin/users' -> 'users'
+  def leaf_name(input)
+    normalize(input).split('/').last
+  end
+
+  def camel_to_snake(str)
+    str.gsub(/::/, '/')
+       .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+       .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+       .downcase
+  end
+
+  def strip_suffixes(name)
+    result = name.dup
+    SUFFIXES.each do |suffix|
+      result = result.delete_suffix(suffix) if result.end_with?(suffix)
+    end
+    result
+  end
+end

data/lib/scaffolding/page_introspector.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'ripper'
+
+class PageIntrospector
+  SKIP_METHODS = %w[initialize url to_s inspect].freeze
+
+  attr_reader :class_name, :methods
+
+  def initialize(file_path)
+    @source = File.read(file_path)
+    @class_name = extract_class_name
+    @methods = extract_public_methods
+  end
+
+  private
+
+  def extract_class_name
+    match = @source.match(/class\s+(\w+)/)
+    match ? match[1] : 'UnknownPage'
+  end
+
+  def extract_public_methods
+    in_private = false
+    results = []
+
+    @source.each_line do |line|
+      stripped = line.strip
+      in_private = true if stripped.match?(/^\s*(private|protected)\s*$/)
+      next if in_private
+
+      match = stripped.match(/^\s*def\s+(\w+)(\(([^)]*)\))?/)
+      next unless match
+
+      method_name = match[1]
+      next if SKIP_METHODS.include?(method_name)
+      next if method_name.start_with?('_')
+
+      params = match[3]&.split(',')&.map(&:strip) || []
+      results << { name: method_name, params: }
+    end
+
+    results
+  end
+end

data/lib/scaffolding/project_detector.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module ScaffoldProjectDetector
+  AUTOMATION_GEMS = {
+    'capybara' => 'capybara',
+    'watir' => 'watir',
+    'selenium-webdriver' => 'selenium',
+    'appium_lib' => 'appium',
+    'eyes_selenium' => 'selenium',
+    'axe-core-rspec' => 'selenium',
+    'axe-core-cucumber' => 'selenium'
+  }.freeze
+
+  FRAMEWORK_GEMS = {
+    'rspec' => 'rspec',
+    'cucumber' => 'cucumber',
+    'minitest' => 'minitest'
+  }.freeze
+
+  CONFIG_PATH = 'config/config.yml'
+
+  class Error < StandardError; end
+
+  module_function
+
+  def detect
+    gemfile = read_gemfile
+    {
+      automation: detect_automation(gemfile),
+      framework: detect_framework(gemfile),
+      has_spec: Dir.exist?('spec'),
+      has_features: Dir.exist?('features'),
+      has_test: Dir.exist?('test')
+    }
+  end
+
+  def detect_automation(gemfile = read_gemfile)
+    AUTOMATION_GEMS.each do |gem_name, automation|
+      return automation if gemfile.include?("'#{gem_name}'") || gemfile.include?("\"#{gem_name}\"")
+    end
+    'selenium'
+  end
+
+  def detect_framework(gemfile = read_gemfile)
+    FRAMEWORK_GEMS.each do |gem_name, framework|
+      return framework if gemfile.include?("'#{gem_name}'") || gemfile.include?("\"#{gem_name}\"")
+    end
+    'rspec'
+  end
+
+  def read_gemfile
+    return '' unless File.exist?('Gemfile')
+
+    File.read('Gemfile')
+  end
+
+  def selenium?
+    detect_automation == 'selenium'
+  end
+
+  def capybara?
+    detect_automation == 'capybara'
+  end
+
+  def watir?
+    detect_automation == 'watir'
+  end
+
+  # Validates that the current directory looks like a Ruby Raider project.
+  # Returns an array of warning messages (empty = valid project).
+  def validate_project
+    warnings = []
+    warnings << 'Gemfile not found. Are you in a Ruby Raider project directory?' unless File.exist?('Gemfile')
+    unless File.exist?(CONFIG_PATH)
+      warnings << "#{CONFIG_PATH} not found. Scaffolded pages won't include URL navigation methods."
+    end
+    warnings
+  end
+
+  # Loads and parses config/config.yml. Returns a hash.
+  # Raises ScaffoldProjectDetector::Error on malformed YAML.
+  def config
+    return {} unless File.exist?(CONFIG_PATH)
+
+    YAML.safe_load(File.read(CONFIG_PATH), permitted_classes: [Symbol]) || {}
+  rescue Psych::SyntaxError => e
+    raise Error, "#{CONFIG_PATH} has invalid YAML syntax: #{e.message}"
+  end
+
+  # Returns the custom path for a scaffold type from config, or nil.
+  def config_path(type)
+    config["#{type}_path"]
+  end
+end

data/lib/scaffolding/scaffold_menu.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'tty-prompt'
+require_relative 'project_detector'
+
+class ScaffoldMenu
+  COMPONENTS = {
+    'Page object' => :page,
+    'Spec (RSpec)' => :spec,
+    'Feature (Cucumber)' => :feature,
+    'Steps (Cucumber)' => :steps,
+    'Helper' => :helper,
+    'Component' => :component,
+    'Model data' => :model
+  }.freeze
+
+  def initialize
+    @prompt = TTY::Prompt.new
+  end
+
+  def run
+    names = ask_names
+    components = ask_components
+    uses = ask_relationships
+    preview_and_confirm(names, components, uses)
+  end
+
+  # Programmatic entry point for raider_desktop
+  def self.build_options(names:, components:, uses: [])
+    { names: Array(names), components: Array(components), uses: Array(uses) }
+  end
+
+  private
+
+  def ask_names
+    input = @prompt.ask('Enter scaffold name(s), comma-separated:') do |q|
+      q.required true
+    end
+    input.split(',').map(&:strip).reject(&:empty?)
+  end
+
+  def ask_components
+    project = ScaffoldProjectDetector.detect
+    defaults = default_components(project)
+
+    @prompt.multi_select('Select components to generate:', default: defaults) do |menu|
+      COMPONENTS.each do |label, value|
+        menu.choice label, value
+      end
+    end
+  end
+
+  def ask_relationships
+    return [] unless @prompt.yes?('Add page dependencies (--uses)?', default: false)
+
+    pages = Dir.glob('page_objects/pages/*.rb').map { |f| File.basename(f, '.rb') }
+    return [] if pages.empty?
+
+    @prompt.multi_select('Select dependent pages:', pages)
+  end
+
+  def preview_and_confirm(names, components, uses)
+    files = planned_files(names, components)
+
+    @prompt.say("\nWill create:")
+    files.each { |f| @prompt.say("  #{f}") }
+    @prompt.say('')
+
+    return nil unless @prompt.yes?('Proceed?')
+
+    { names:, components:, uses: }
+  end
+
+  def planned_files(names, components)
+    names.flat_map do |name|
+      components.map { |comp| file_for(name, comp) }
+    end
+  end
+
+  def file_for(name, component)
+    case component
+    when :page then "page_objects/pages/#{name}.rb"
+    when :spec then "spec/#{name}_page_spec.rb"
+    when :feature then "features/#{name}.feature"
+    when :steps then "features/step_definitions/#{name}_steps.rb"
+    when :helper then "helpers/#{name}_helper.rb"
+    when :component then "page_objects/components/#{name}.rb"
+    when :model then "models/data/#{name}.yml"
+    end
+  end
+
+  def default_components(project)
+    defaults = [:page]
+    if project[:has_features]
+      defaults += %i[feature steps]
+    elsif project[:has_test]
+      defaults << :spec
+    else
+      defaults << :spec
+    end
+    defaults.map { |d| COMPONENTS.key(d) }.compact
+  end
+end