ruby_raider 1.1.4 → 2.0.0

data/lib/adopter/plan_builder.rb

@@ -0,0 +1,278 @@
+# frozen_string_literal: true
+
+require_relative 'migration_plan'
+require_relative 'converters/identity_converter'
+
+module Adopter
+  # :reek:TooManyMethods { enabled: false }
+  class PlanBuilder
+    def initialize(analysis, params)
+      @analysis = analysis
+      @params = params
+      @warnings = []
+      @manual_actions = []
+    end
+
+    def build
+      MigrationPlan.new(
+        source_path: @params[:source_path],
+        output_path: @params[:output_path],
+        target_automation: @params[:target_automation],
+        target_framework: @params[:target_framework],
+        ci_platform: @params[:ci_platform],
+        skeleton_structure: build_skeleton_structure,
+        converted_pages: plan_page_conversions,
+        converted_tests: plan_test_conversions,
+        converted_features: plan_feature_conversions,
+        converted_steps: plan_step_conversions,
+        gemfile_additions: @analysis[:custom_gems] || [],
+        config_overrides: extract_config_overrides,
+        warnings: @warnings,
+        manual_actions: @manual_actions
+      )
+    end
+
+    private
+
+    def build_skeleton_structure
+      {
+        automation: @params[:target_automation],
+        framework: @params[:target_framework],
+        name: @params[:output_path],
+        ci_platform: @params[:ci_platform]
+      }
+    end
+
+    def plan_page_conversions
+      pages = @analysis[:pages] || []
+      pages.map do |page|
+        source_file = File.join(@params[:source_path], page[:path])
+        content = File.read(source_file)
+        converted = convert_page(content, page)
+
+        ConvertedFile.new(
+          output_path: raider_page_path(page[:class_name]),
+          content: converted,
+          source_file: page[:path],
+          conversion_notes: page_conversion_notes
+        )
+      end
+    end
+
+    def plan_test_conversions
+      tests = @analysis[:tests] || []
+      return [] if target_cucumber?
+
+      tests.select { |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)
+
+        ConvertedFile.new(
+          output_path: raider_test_path(test),
+          content: converted,
+          source_file: test[:path],
+          conversion_notes: test_conversion_notes(test[:type])
+        )
+      end
+    end
+
+    def plan_feature_conversions
+      return [] unless target_cucumber?
+
+      features = @analysis[:features] || []
+      features.map do |feature|
+        source_file = File.join(@params[:source_path], feature[:path])
+        content = File.read(source_file)
+
+        ConvertedFile.new(
+          output_path: raider_feature_path(feature[:path]),
+          content: content,
+          source_file: feature[:path],
+          conversion_notes: 'Feature file copied as-is'
+        )
+      end
+    end
+
+    def plan_step_conversions
+      return [] unless target_cucumber?
+
+      steps = @analysis[:step_definitions] || []
+      steps.map do |step|
+        source_file = File.join(@params[:source_path], step[:path])
+        content = File.read(source_file)
+        converted = convert_step_page_references(content)
+
+        ConvertedFile.new(
+          output_path: raider_step_path(step[:path]),
+          content: converted,
+          source_file: step[:path],
+          conversion_notes: 'Step definitions with updated page references'
+        )
+      end
+    end
+
+    # --- Page conversion ---
+
+    def convert_page(content, page)
+      source_dsl = @analysis[:source_dsl]
+      target = @params[:target_automation]
+
+      if same_automation_dsl?(source_dsl, target)
+        restructure_page(content)
+      else
+        convert_page_dsl(content, page, source_dsl, target)
+      end
+    end
+
+    # :reek:ControlParameter { enabled: false }
+    def convert_page_dsl(content, page, source_dsl, target)
+      converter = find_page_converter(source_dsl, target)
+      if converter
+        converter.call(content, page)
+      else
+        add_warning("No converter for #{source_dsl} → #{target}. Page '#{page[:class_name]}' copied as-is.")
+        restructure_page(content)
+      end
+    end
+
+    def find_page_converter(source_dsl, target)
+      key = :"#{normalize_dsl(source_dsl)}_to_#{target}"
+      page_converters[key]
+    end
+
+    def page_converters
+      @page_converters ||= {}
+    end
+
+    def register_page_converter(key, converter)
+      page_converters[key] = converter
+    end
+
+    # --- Test conversion ---
+
+    def convert_test(content, test)
+      source_framework = test[:type]
+      target = @params[:target_framework]
+
+      if source_framework.to_s == target
+        restructure_test(content)
+      else
+        convert_test_framework(content, test, source_framework, target)
+      end
+    end
+
+    # :reek:ControlParameter { enabled: false }
+    def convert_test_framework(content, test, source_framework, target)
+      converter = find_test_converter(source_framework, target)
+      if converter
+        converter.call(content, test)
+      else
+        add_warning("No converter for #{source_framework} → #{target}. Test '#{test[:path]}' copied as-is.")
+        restructure_test(content)
+      end
+    end
+
+    def find_test_converter(source_framework, target)
+      key = :"#{source_framework}_to_#{target}"
+      test_converters[key]
+    end
+
+    def test_converters
+      @test_converters ||= {}
+    end
+
+    # --- Restructuring (identity conversion) ---
+
+    def identity_converter
+      @identity_converter ||= Converters::IdentityConverter.new(@params[:target_automation])
+    end
+
+    def restructure_page(content)
+      identity_converter.convert_page(content, {})
+    end
+
+    def restructure_test(content)
+      identity_converter.convert_test(content, {})
+    end
+
+    def convert_step_page_references(content)
+      identity_converter.convert_step(content)
+    end
+
+    # --- Path helpers ---
+
+    def raider_page_path(class_name)
+      filename = class_name.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+      filename = filename.delete_suffix('_page')
+      "#{@params[:output_path]}/page_objects/pages/#{filename}.rb"
+    end
+
+    def raider_test_path(test)
+      basename = File.basename(test[:path], '.rb')
+      target = @params[:target_framework]
+
+      case target
+      when 'rspec'
+        name = basename.delete_prefix('test_').delete_suffix('_spec')
+        "#{@params[:output_path]}/spec/#{name}_spec.rb"
+      when 'minitest'
+        name = basename.delete_prefix('test_').delete_suffix('_test').delete_suffix('_spec')
+        "#{@params[:output_path]}/test/test_#{name}.rb"
+      else
+        "#{@params[:output_path]}/spec/#{basename}.rb"
+      end
+    end
+
+    def raider_feature_path(source_path)
+      filename = File.basename(source_path)
+      "#{@params[:output_path]}/features/#{filename}"
+    end
+
+    def raider_step_path(source_path)
+      filename = File.basename(source_path)
+      "#{@params[:output_path]}/features/step_definitions/#{filename}"
+    end
+
+    # --- Config ---
+
+    def extract_config_overrides
+      overrides = {}
+      overrides[:browser] = @params[:browser] || @analysis[:browser]
+      overrides[:url] = @params[:url] || @analysis[:url]
+      overrides.compact
+    end
+
+    # --- Helpers ---
+
+    def same_automation_dsl?(source_dsl, target)
+      normalize_dsl(source_dsl) == target
+    end
+
+    def normalize_dsl(dsl)
+      case dsl
+      when :site_prism then 'capybara'
+      else dsl.to_s
+      end
+    end
+
+    def target_cucumber?
+      @params[:target_framework] == 'cucumber'
+    end
+
+    def page_conversion_notes
+      source = @analysis[:source_dsl]
+      target = @params[:target_automation]
+      same_automation_dsl?(source, target) ? 'Restructured to Raider conventions' : "Converted from #{source} to #{target}"
+    end
+
+    def test_conversion_notes(source_type)
+      target = @params[:target_framework]
+      source_type.to_s == target ? 'Restructured to Raider conventions' : "Converted from #{source_type} to #{target}"
+    end
+
+    def add_warning(message)
+      @warnings << message
+    end
+  end
+end

data/lib/adopter/project_analyzer.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+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
+      appium_lib appium_console axe-core-rspec axe-core-selenium capybara
+      cucumber eyes_selenium eyes_universal minitest minitest-reporters
+      parallel_split_test parallel_tests rake reek rspec rubocop rubocop-rspec
+      rubocop-minitest ruby_raider selenium-webdriver site_prism watir
+    ].freeze
+
+    PAGE_DSL_PATTERNS = {
+      site_prism: /class\s+\w+\s*<\s*SitePrism::Page/,
+      capybara: /include\s+Capybara::DSL|\.fill_in\b|\.click_on\b|\.click_button\b/,
+      selenium: /\.find_element\s*\(|driver\.navigate/,
+      watir: /browser\.text_field|browser\.button|browser\.element/
+    }.freeze
+
+    PAGE_CLASS_PATTERNS = [
+      /class\s+\w+\s*<\s*SitePrism::Page/,
+      /class\s+\w+\s*<\s*(?:Page|BasePage|AbstractPage)/,
+      /include\s+Capybara::DSL/,
+      /\.find_element\s*\(/,
+      /browser\.text_field|browser\.button/,
+      /def\s+(?:visit|login|click_|fill_|select_|navigate)/
+    ].freeze
+
+    TEST_FILE_PATTERNS = {
+      rspec: { glob: '**/*_spec.rb', marker: /\b(?:describe|context|it)\b/ },
+      cucumber_feature: { glob: '**/*.feature', marker: /\b(?:Feature|Scenario)\b/ },
+      cucumber_step: { glob: '**/*_steps.rb', marker: /\b(?:Given|When|Then)\b/ },
+      minitest: { glob: '**/test_*.rb', marker: /class\s+\w+\s*<\s*Minitest::Test/ },
+      minitest_alt: { glob: '**/*_test.rb', marker: /class\s+\w+\s*<\s*Minitest::Test/ }
+    }.freeze
+
+    HELPER_ROLES = {
+      driver: /module\s+DriverHelper|def\s+(?:driver|create_driver)\b/,
+      browser: /module\s+BrowserHelper|def\s+(?:browser|create_browser)\b/,
+      capybara: /Capybara\.configure|Capybara\.register_driver/,
+      env: /^(?:Before|After)\s+do\b/,
+      factory: /FactoryBot|ModelFactory|def\s+self\.for\b/,
+      spec_helper: /RSpec\.configure|Minitest::Test/
+    }.freeze
+
+    def initialize(source_path, overrides = {})
+      @source_path = source_path
+      @overrides = overrides
+    end
+
+    def analyze
+      detection = ProjectDetector.detect(@source_path)
+      validate_web_only!(detection)
+
+      {
+        **detection,
+        **@overrides.compact,
+        pages: discover_pages,
+        tests: discover_tests,
+        helpers: discover_helpers,
+        features: discover_features,
+        step_definitions: discover_step_definitions,
+        custom_gems: discover_custom_gems,
+        source_dsl: detect_page_dsl
+      }
+    end
+
+    private
+
+    def validate_web_only!(detection)
+      return unless detection[:automation] == 'appium'
+
+      raise MobileProjectError,
+            '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
+
+      ruby_files_in(page_path).filter_map do |file|
+        content = File.read(file)
+        next unless page_like?(content)
+
+        {
+          path: relative_path(file),
+          class_name: extract_class_name(content),
+          base_class: extract_base_class(content),
+          methods: extract_public_methods(content)
+        }
+      end
+    end
+
+    def discover_tests
+      results = []
+      TEST_FILE_PATTERNS.each do |type, config|
+        Dir.glob(File.join(@source_path, config[:glob])).each do |file|
+          content = File.read(file)
+          next unless content.match?(config[:marker])
+
+          results << {
+            path: relative_path(file),
+            type: type.to_s.split('_').first.to_sym,
+            class_name: extract_class_name(content),
+            test_methods: extract_test_methods(content, type)
+          }
+        end
+      end
+      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')) +
+                     Dir.glob(File.join(@source_path, '**', 'env.rb'))
+
+      helper_files.uniq.first(30).filter_map do |file|
+        next unless File.file?(file)
+
+        content = File.read(file)
+        role = detect_helper_role(content)
+
+        {
+          path: relative_path(file),
+          role: role,
+          modules_defined: extract_modules(content)
+        }
+      end
+    end
+
+    def discover_features
+      Dir.glob(File.join(@source_path, '**', '*.feature')).map do |file|
+        {
+          path: relative_path(file),
+          scenarios: count_scenarios(File.read(file))
+        }
+      end
+    end
+
+    def discover_step_definitions
+      Dir.glob(File.join(@source_path, '**', '*_steps.rb')).map do |file|
+        {
+          path: relative_path(file),
+          steps: count_steps(File.read(file))
+        }
+      end
+    end
+
+    # :reek:NestedIterators { enabled: false }
+    def discover_custom_gems
+      gemfile = File.join(@source_path, 'Gemfile')
+      return [] unless File.exist?(gemfile)
+
+      ProjectDetector.send(:parse_gemfile, @source_path).reject do |gem_name|
+        KNOWN_FRAMEWORK_GEMS.include?(gem_name)
+      end
+    end
+
+    def detect_page_dsl
+      page_files = discover_pages.map { |p| File.join(@source_path, p[:path]) }
+      return :raw if page_files.empty?
+
+      page_contents = page_files.first(20).map { |f| File.read(f) }.join("\n")
+
+      PAGE_DSL_PATTERNS.each do |dsl, pattern|
+        return dsl if page_contents.match?(pattern)
+      end
+
+      :raw
+    end
+
+    # --- File discovery helpers ---
+
+    def detect_page_dir
+      detected = ProjectDetector.detect_page_path(@source_path)
+      return File.join(@source_path, detected) if detected
+
+      # Fallback: scan all .rb files for page-like classes
+      nil
+    end
+
+    def ruby_files_in(dir)
+      Dir.glob(File.join(dir, '**', '*.rb'))
+    end
+
+    def relative_path(absolute)
+      absolute.sub("#{@source_path}/", '')
+    end
+
+    # --- Content analysis helpers ---
+
+    def page_like?(content)
+      PAGE_CLASS_PATTERNS.any? { |pattern| content.match?(pattern) }
+    end
+
+    def extract_class_name(content)
+      match = content.match(/class\s+(\w+)/)
+      match&.[](1)
+    end
+
+    def extract_base_class(content)
+      match = content.match(/class\s+\w+\s*<\s*([\w:]+)/)
+      match&.[](1)
+    end
+
+    def extract_public_methods(content)
+      in_private = false
+      content.each_line.filter_map do |line|
+        in_private = true if line.match?(/^\s*private\b/)
+        next if in_private
+
+        match = line.match(/^\s*def\s+(\w+)/)
+        match[1] if match && match[1] != 'initialize'
+      end
+    end
+
+    def extract_test_methods(content, type)
+      case type
+      when :rspec
+        content.scan(/\bit\s+['"]([^'"]+)['"]/).flatten
+      when :minitest, :minitest_alt
+        content.scan(/def\s+(test_\w+)/).flatten
+      when :cucumber_step
+        content.scan(/(?:Given|When|Then)\(['"]([^'"]+)['"]/).flatten
+      else
+        []
+      end
+    end
+
+    def extract_modules(content)
+      content.scan(/module\s+(\w+)/).flatten
+    end
+
+    def detect_helper_role(content)
+      HELPER_ROLES.each do |role, pattern|
+        return role if content.match?(pattern)
+      end
+      :custom
+    end
+
+    def count_scenarios(content)
+      content.scan(/^\s*Scenario/).length
+    end
+
+    def count_steps(content)
+      content.scan(/^\s*(?:Given|When|Then|And|But)\b/).length
+    end
+  end
+end

data/lib/adopter/project_detector.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Adopter
+  # :reek:TooManyMethods { enabled: false }
+  module ProjectDetector
+    GEM_AUTOMATION_MAP = {
+      'site_prism' => 'capybara',
+      'capybara' => 'capybara',
+      'selenium-webdriver' => 'selenium',
+      'watir' => 'watir',
+      'appium_lib' => 'appium',
+      'eyes_selenium' => 'applitools',
+      'axe-core-selenium' => 'axe',
+      'axe-core-rspec' => 'axe'
+    }.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
+
+    # :reek:NestedIterators { enabled: false }
+    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