ruby_raider 1.1.4 → 3.0.0

data/lib/adopter/migrator.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'yaml'
+require_relative '../generators/invoke_generators'
+
+module Adopter
+  class Migrator
+    attr_reader :plan, :results
+
+    def initialize(plan)
+      @plan = plan
+      @results = { pages: 0, tests: 0, features: 0, steps: 0, errors: [] }
+    end
+
+    def execute
+      generate_skeleton
+      write_converted_pages
+      write_converted_tests
+      write_converted_features
+      write_converted_steps
+      merge_gemfile
+      apply_config_overrides
+      results
+    end
+
+    private
+
+    # Phase A: Generate a standard Raider project skeleton
+    def generate_skeleton
+      InvokeGenerators.generate_framework(plan.skeleton_structure)
+    end
+
+    # Phase B: Overlay converted user files on top of the skeleton
+
+    def write_converted_pages
+      plan.converted_pages.each do |file|
+        write_file(file)
+        @results[:pages] += 1
+      end
+    end
+
+    def write_converted_tests
+      plan.converted_tests.each do |file|
+        write_file(file)
+        @results[:tests] += 1
+      end
+    end
+
+    def write_converted_features
+      plan.converted_features.each do |file|
+        write_file(file)
+        @results[:features] += 1
+      end
+    end
+
+    def write_converted_steps
+      plan.converted_steps.each do |file|
+        write_file(file)
+        @results[:steps] += 1
+      end
+    end
+
+    def write_file(converted_file)
+      FileUtils.mkdir_p(File.dirname(converted_file.output_path))
+      File.write(converted_file.output_path, converted_file.content)
+    rescue StandardError => e
+      @results[:errors] << "Failed to write #{converted_file.output_path}: #{e.message}"
+    end
+
+    def merge_gemfile
+      return if plan.gemfile_additions.empty?
+
+      gemfile_path = "#{plan.output_path}/Gemfile"
+      return unless File.exist?(gemfile_path)
+
+      content = File.read(gemfile_path)
+      additions = plan.gemfile_additions.reject { |gem| content.include?("'#{gem}'") }
+      return if additions.empty?
+
+      gem_lines = additions.map { |gem| "gem '#{gem}'" }.join("\n")
+      File.write(gemfile_path, "#{content}\n# Gems from source project\n#{gem_lines}\n")
+    end
+
+    def apply_config_overrides
+      return if plan.config_overrides.empty?
+
+      config_path = "#{plan.output_path}/config/config.yml"
+      return unless File.exist?(config_path)
+
+      config = YAML.safe_load(File.read(config_path), permitted_classes: [Symbol]) || {}
+      plan.config_overrides.each { |key, value| config[key.to_s] = value }
+      File.write(config_path, YAML.dump(config))
+    end
+  end
+end

data/lib/adopter/plan_builder.rb

@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require_relative 'migration_plan'
+require_relative 'converters/identity_converter'
+
+module Adopter
+  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.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)
+
+        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:,
+          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
+
+    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
+
+    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,252 @@
+# frozen_string_literal: true
+
+require_relative 'project_detector'
+
+module Adopter
+  class MobileProjectError < StandardError; end
+
+  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
+
+    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
+
+    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:,
+          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
+
+    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