ruby_raider 3.0.1 → 3.2.0

data/lib/adopter/migrator.rb

@@ -1,96 +0,0 @@
-# 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

@@ -1,275 +0,0 @@
-# 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

@@ -1,252 +0,0 @@
-# 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