ruby_raider 3.0.1 → 3.1.0

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

data/lib/adopter/project_detector.rb

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