ruby_raider 1.1.4 → 3.0.0

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,72 @@
+# frozen_string_literal: true
+
+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
+
+  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
+
+  def config
+    return {} unless File.exist?('config/config.yml')
+
+    YAML.safe_load(File.read('config/config.yml'), permitted_classes: [Symbol]) || {}
+  rescue StandardError
+    {}
+  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

data/lib/scaffolding/scaffolding.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 require 'thor'
+require 'yaml'
+require_relative 'name_normalizer'
+require_relative 'project_detector'
 
 class Scaffolding < Thor::Group
   include Thor::Actions
@@ -8,28 +11,48 @@ class Scaffolding < Thor::Group
   argument :name, optional: true
   argument :path, optional: true
 
+  attr_writer :uses
+
+  OVERRIDE_DIR = '.ruby_raider/templates'
+
   def self.source_root
     "#{File.dirname(__FILE__)}/templates"
   end
 
+  # Check for user template override before using default
+  def template(source, *args, &block)
+    override = File.join(OVERRIDE_DIR, File.basename(source))
+    if File.exist?(override)
+      super(File.expand_path(override), *args, &block)
+    else
+      super
+    end
+  end
+
+  # --- Generation methods ---
+
   def generate_page
-    template('page_object.tt', default_path("page_objects/pages/#{name}.rb", '_page.rb'))
+    template('page_object.tt', default_path("page_objects/pages/#{normalized_name}.rb", '_page.rb'))
   end
 
   def generate_feature
-    template('feature.tt', default_path("features/#{name}.feature", '.feature'))
+    template('feature.tt', default_path("features/#{normalized_name}.feature", '.feature'))
   end
 
   def generate_spec
-    template('spec.tt', default_path("spec/#{name}_page_spec.rb", '_spec.rb'))
+    template('spec.tt', default_path("spec/#{normalized_name}_page_spec.rb", '_spec.rb'))
   end
 
   def generate_helper
-    template('helper.tt', default_path("helpers/#{name}_helper.rb", '_helper.rb'))
+    template('helper.tt', default_path("helpers/#{normalized_name}_helper.rb", '_helper.rb'))
   end
 
   def generate_steps
-    template('steps.tt', default_path("features/step_definitions/#{name}_steps.rb", '_steps.rb'))
+    template('steps.tt', default_path("features/step_definitions/#{normalized_name}_steps.rb", '_steps.rb'))
+  end
+
+  def generate_component
+    template('component.tt', default_path("page_objects/components/#{normalized_name}.rb", '.rb'))
   end
 
   def generate_config
@@ -37,31 +60,155 @@ class Scaffolding < Thor::Group
              default_path('config/config.yml', '.yml'))
   end
 
+  def generate_spec_from_page(source_file, ai: false) # rubocop:disable Naming/MethodParameterName
+    require_relative 'page_introspector'
+    @introspected = PageIntrospector.new(source_file)
+    enrich_with_ai_scenarios if ai
+    template('spec_from_page.tt', "spec/#{normalized_name}_spec.rb")
+  end
+
+  def generate_page_from_url(analysis)
+    @url_data = analysis
+    template('page_from_url.tt', "page_objects/pages/#{normalized_name}.rb")
+  end
+
+  def generate_spec_from_url(analysis)
+    @url_data = analysis
+    template('spec_from_url.tt', "spec/#{normalized_name}_spec.rb")
+  end
+
+  # --- Deletion methods ---
+
   def delete_page
-    remove_file(default_path("page_objects/pages/#{name}.rb", '_page.rb'))
+    remove_file(default_path("page_objects/pages/#{normalized_name}.rb", '_page.rb'))
   end
 
   def delete_feature
-    remove_file(default_path("features/#{name}.feature", '.feature'))
+    remove_file(default_path("features/#{normalized_name}.feature", '.feature'))
   end
 
   def delete_spec
-    remove_file(default_path("spec/#{name}_page_spec.rb", '_spec.rb'))
+    remove_file(default_path("spec/#{normalized_name}_page_spec.rb", '_spec.rb'))
   end
 
   def delete_helper
-    remove_file(default_path("helpers/#{name}_helper.rb", '_helper.rb'))
+    remove_file(default_path("helpers/#{normalized_name}_helper.rb", '_helper.rb'))
   end
 
   def delete_steps
-    remove_file(default_path("features/step_definitions/#{name}_steps.rb", '_steps.rb'))
+    remove_file(default_path("features/step_definitions/#{normalized_name}_steps.rb", '_steps.rb'))
+  end
+
+  def delete_component
+    remove_file(default_path("page_objects/components/#{normalized_name}.rb", '.rb'))
   end
 
   def delete_config
     remove_file(default_path('config/config.yml', '.yml'))
   end
 
+  # --- Path planning (for dry-run) ---
+
+  def self.planned_path(name, type, custom_path = nil)
+    n = NameNormalizer.normalize(name)
+    case type.to_s
+    when 'page' then custom_path ? "#{custom_path}/#{n}_page.rb" : "page_objects/pages/#{n}.rb"
+    when 'spec' then custom_path ? "#{custom_path}/#{n}_spec.rb" : "spec/#{n}_page_spec.rb"
+    when 'feature' then custom_path ? "#{custom_path}/#{n}.feature" : "features/#{n}.feature"
+    when 'steps' then custom_path ? "#{custom_path}/#{n}_steps.rb" : "features/step_definitions/#{n}_steps.rb"
+    when 'helper' then custom_path ? "#{custom_path}/#{n}_helper.rb" : "helpers/#{n}_helper.rb"
+    when 'component' then custom_path ? "#{custom_path}/#{n}.rb" : "page_objects/components/#{n}.rb"
+    when 'model' then "models/data/#{n}.yml"
+    end
+  end
+
+  # --- Template helpers (available in .tt files) ---
+
+  def class_name
+    NameNormalizer.to_class_name(name)
+  end
+
+  def page_class_name
+    NameNormalizer.to_page_class(name)
+  end
+
+  def normalized_name
+    NameNormalizer.normalize(name)
+  end
+
+  def nested?
+    NameNormalizer.nested?(name)
+  end
+
+  def module_parts
+    NameNormalizer.module_parts(name)
+  end
+
+  def leaf_name
+    NameNormalizer.leaf_name(name)
+  end
+
+  def automation_type
+    ScaffoldProjectDetector.detect_automation
+  end
+
+  def framework_type
+    ScaffoldProjectDetector.detect_framework
+  end
+
+  def project_config
+    ScaffoldProjectDetector.config
+  end
+
+  def selenium?
+    automation_type == 'selenium'
+  end
+
+  def capybara?
+    automation_type == 'capybara'
+  end
+
+  def watir?
+    automation_type == 'watir'
+  end
+
+  def uses_list
+    Array(@uses).reject(&:empty?)
+  end
+
+  attr_reader :introspected, :url_data
+
+  def ai_scenarios
+    @ai_scenarios || {}
+  end
+
   def default_path(standard_path, file_type)
-    path ? "#{path}/#{name}#{file_type}" : standard_path
+    path ? "#{path}/#{normalized_name}#{file_type}" : standard_path
+  end
+
+  private
+
+  def enrich_with_ai_scenarios
+    require_relative '../llm/client'
+    require_relative '../llm/prompts'
+    require_relative '../llm/response_parser'
+
+    return unless Llm::Client.available?
+
+    response = Llm::Client.complete(
+      Llm::Prompts.generate_test_scenarios(
+        @introspected.class_name,
+        @introspected.methods,
+        automation_type,
+        framework_type
+      ),
+      system_prompt: Llm::Prompts.system_prompt
+    )
+    scenarios = Llm::ResponseParser.extract_scenarios(response)
+    return unless scenarios
+
+    @ai_scenarios = scenarios.each_with_object({}) do |s, hash|
+      hash[s[:method]] = s
+    end
   end
 end

data/lib/scaffolding/templates/component.tt

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative '../abstract/component'
+
+class <%= class_name %> < Component
+<%- if capybara? -%>
+
+  # Example: find('.selector').text
+<%- elsif selenium? -%>
+
+  def content
+    component.text
+  end
+
+  private
+
+  # Elements
+  # Example: driver.find_element(css: '.selector')
+<%- elsif watir? -%>
+
+  def content
+    component.text
+  end
+
+  private
+
+  # Elements
+  # Example: browser.element(css: '.selector')
+<%- end -%>
+end

data/lib/scaffolding/templates/feature.tt

@@ -1,6 +1,6 @@
-Feature: <%= name.capitalize %>
+Feature: <%= class_name %>
 
 Scenario: Scenario name
-    Given I am
-    When I do
-    Then I see
+    Given I am on the <%= normalized_name.tr('_', ' ') %> page
+    When I perform an action
+    Then I see the expected result

data/lib/scaffolding/templates/helper.tt

@@ -1,3 +1,17 @@
-module <%= name.split('_').map {|word| word.capitalize }.join + 'Helper' %>
+# frozen_string_literal: true
+
+<% if nested? -%>
+<% module_parts.each_with_index do |mod, i| -%>
+<%= '  ' * i %>module <%= mod %>
+<% end -%>
+<%= '  ' * module_parts.size %>module <%= NameNormalizer.to_class_name(leaf_name) %>Helper
+<%= '  ' * module_parts.size %>  # Add your helper code here
+<%= '  ' * module_parts.size %>end
+<% module_parts.each_with_index do |_mod, i| -%>
+<%= '  ' * (module_parts.size - i - 1) %>end
+<% end -%>
+<% else -%>
+module <%= class_name %>Helper
   # Add your helper code here
 end
+<% end -%>