ruby_raider 1.1.4 → 2.0.0

data/lib/adopter/adopt_menu.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require 'tty-prompt'
+require_relative 'project_analyzer'
+require_relative 'plan_builder'
+require_relative 'migrator'
+
+module Adopter
+  # :reek:TooManyMethods { enabled: false }
+  class AdoptMenu
+    WEB_AUTOMATIONS = %w[selenium capybara watir].freeze
+    TEST_FRAMEWORKS = %w[rspec cucumber minitest].freeze
+    CI_PLATFORMS = %w[github gitlab].freeze
+
+    def initialize
+      @prompt = TTY::Prompt.new
+    end
+
+    def run
+      source_path = ask_source_path
+      detection = preview_detection(source_path)
+      target_automation = ask_target_automation(detection[:automation])
+      target_framework = ask_target_framework(detection[:framework])
+      output_path = ask_output_path
+      ci_platform = ask_ci_platform(detection[:ci_platform])
+
+      execute_adoption(
+        source_path: source_path,
+        output_path: output_path,
+        target_automation: target_automation,
+        target_framework: target_framework,
+        ci_platform: ci_platform
+      )
+    end
+
+    # Programmatic entry point for raider_desktop and CLI --parameters
+    # :reek:LongParameterList { enabled: false }
+    def self.adopt(params)
+      validate_params!(params)
+
+      analysis = ProjectAnalyzer.new(params[:source_path]).analyze
+      plan = PlanBuilder.new(analysis, params).build
+      results = Migrator.new(plan).execute
+
+      { plan: plan, results: results }
+    end
+
+    def self.validate_params!(params)
+      raise ArgumentError, 'source_path is required' unless params[:source_path]
+      raise ArgumentError, 'output_path is required' unless params[:output_path]
+      raise ArgumentError, 'target_automation is required' unless params[:target_automation]
+      raise ArgumentError, 'target_framework is required' unless params[:target_framework]
+
+      unless WEB_AUTOMATIONS.include?(params[:target_automation])
+        raise ArgumentError, "target_automation must be one of: #{WEB_AUTOMATIONS.join(', ')}"
+      end
+
+      return if TEST_FRAMEWORKS.include?(params[:target_framework])
+
+      raise ArgumentError, "target_framework must be one of: #{TEST_FRAMEWORKS.join(', ')}"
+    end
+
+    private
+
+    def ask_source_path
+      path = @prompt.ask('Enter the path to your existing test project:') do |q|
+        q.required true
+        q.validate ->(input) { Dir.exist?(input) }
+        q.messages[:valid?] = 'Directory does not exist: %{value}'
+      end
+      File.expand_path(path)
+    end
+
+    def preview_detection(source_path)
+      detection = ProjectDetector.detect(source_path)
+      @prompt.say("\nDetected project settings:")
+      @prompt.say("  Automation: #{detection[:automation] || 'unknown'}")
+      @prompt.say("  Framework:  #{detection[:framework] || 'unknown'}")
+      @prompt.say("  Browser:    #{detection[:browser] || 'not detected'}")
+      @prompt.say("  URL:        #{detection[:url] || 'not detected'}")
+      @prompt.say("  CI:         #{detection[:ci_platform] || 'none'}")
+      @prompt.say('')
+      detection
+    end
+
+    def ask_target_automation(detected)
+      default = WEB_AUTOMATIONS.include?(detected) ? detected : nil
+      @prompt.select('Select target automation framework:', WEB_AUTOMATIONS.map(&:capitalize),
+                      default: default&.capitalize) do |menu|
+        menu.choice :Quit, -> { exit }
+      end.downcase
+    end
+
+    def ask_target_framework(detected)
+      default = TEST_FRAMEWORKS.include?(detected) ? detected : nil
+      @prompt.select('Select target test framework:', TEST_FRAMEWORKS.map(&:capitalize),
+                      default: default&.capitalize) do |menu|
+        menu.choice :Quit, -> { exit }
+      end.downcase
+    end
+
+    def ask_output_path
+      @prompt.ask('Enter the output path for the new Raider project:') do |q|
+        q.required true
+      end
+    end
+
+    def ask_ci_platform(detected)
+      choices = [{ name: 'Github Actions', value: 'github' },
+                 { name: 'Gitlab CI/CD', value: 'gitlab' },
+                 { name: 'No CI', value: nil }]
+      default = case detected
+                when 'github' then 'Github Actions'
+                when 'gitlab' then 'Gitlab CI/CD'
+                end
+      @prompt.select('Configure CI/CD?', choices, default: default)
+    end
+
+    def execute_adoption(params)
+      @prompt.say("\nAdopting project...")
+      result = self.class.adopt(params)
+      print_results(result[:plan], result[:results])
+    rescue MobileProjectError => e
+      @prompt.error(e.message)
+    rescue StandardError => e
+      @prompt.error("Adoption failed: #{e.message}")
+    end
+
+    def print_results(plan, results)
+      @prompt.say("\nAdoption complete!")
+      @prompt.say("  Pages converted:    #{results[:pages]}")
+      @prompt.say("  Tests converted:    #{results[:tests]}")
+      @prompt.say("  Features copied:    #{results[:features]}")
+      @prompt.say("  Steps converted:    #{results[:steps]}")
+
+      unless results[:errors].empty?
+        @prompt.warn("\nErrors:")
+        results[:errors].each { |e| @prompt.warn("  - #{e}") }
+      end
+
+      unless plan.warnings.empty?
+        @prompt.warn("\nWarnings:")
+        plan.warnings.each { |w| @prompt.warn("  - #{w}") }
+      end
+
+      @prompt.say("\nOutput: #{plan.output_path}")
+      @prompt.say("Run: cd #{plan.output_path} && bundle install")
+    end
+  end
+end

data/lib/adopter/converters/base_converter.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Adopter
+  module Converters
+    class BaseConverter
+      RAIDER_BASE_CLASSES = %w[Page BasePage AbstractPage].freeze
+
+      def convert_page(content, _page_info)
+        content
+      end
+
+      def convert_test(content, _test_info)
+        content
+      end
+
+      private
+
+      def ensure_frozen_string_literal(content)
+        return content if content.include?('frozen_string_literal')
+
+        "# frozen_string_literal: true\n\n#{content}"
+      end
+
+      def update_base_class(content, target_base = 'Page')
+        content.gsub(/class\s+(\w+)\s*<\s*([\w:]+)/) do
+          class_name = ::Regexp.last_match(1)
+          current_base = ::Regexp.last_match(2)
+          if raider_compatible_base?(current_base)
+            "class #{class_name} < #{target_base}"
+          else
+            "class #{class_name} < #{current_base}"
+          end
+        end
+      end
+
+      def raider_compatible_base?(base_class)
+        RAIDER_BASE_CLASSES.include?(base_class) || base_class.include?('Page')
+      end
+
+      def update_require_paths(content, target_automation)
+        result = content.dup
+        result = update_page_requires(result)
+        result = update_helper_requires(result, target_automation)
+        result
+      end
+
+      def update_page_requires(content)
+        content.gsub(%r{require_relative\s+['"]\.*/(?:pages?|page_objects)/(\w+)['"]}) do
+          page_name = ::Regexp.last_match(1)
+          "require_relative '../page_objects/pages/#{page_name}'"
+        end
+      end
+
+      def update_helper_requires(content, target_automation)
+        case target_automation
+        when 'capybara'
+          content.gsub(%r{require_relative\s+['"]\.*/(?:helpers?|support)/(?:driver|browser)_?\w*['"]},
+                       "require_relative '../helpers/capybara_helper'")
+        when 'watir'
+          content.gsub(%r{require_relative\s+['"]\.*/(?:helpers?|support)/(?:driver|capybara)_?\w*['"]},
+                       "require_relative '../helpers/browser_helper'")
+        else
+          content.gsub(%r{require_relative\s+['"]\.*/(?:helpers?|support)/(?:browser|capybara)_?\w*['"]},
+                       "require_relative '../helpers/driver_helper'")
+        end
+      end
+
+      def remove_driver_arg(content)
+        content.gsub(/(\w+)\.new\(\s*(?:driver|browser|page)\s*\)/, '\1.new')
+      end
+
+      def swap_driver_arg(content, target_arg)
+        content.gsub(/(\w+)\.new\(\s*(?:driver|browser|page)\s*\)/, "\\1.new(#{target_arg})")
+      end
+
+      def driver_arg_for(target_automation)
+        case target_automation
+        when 'watir' then 'browser'
+        when 'capybara' then nil
+        else 'driver'
+        end
+      end
+    end
+  end
+end

data/lib/adopter/converters/identity_converter.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'base_converter'
+
+module Adopter
+  module Converters
+    class IdentityConverter < BaseConverter
+      def initialize(target_automation)
+        super()
+        @target_automation = target_automation
+      end
+
+      def convert_page(content, _page_info)
+        result = content.dup
+        result = ensure_frozen_string_literal(result)
+        result = update_base_class(result)
+        result = add_page_require(result)
+        result = update_page_instantiation(result)
+        result
+      end
+
+      def convert_test(content, _test_info)
+        result = content.dup
+        result = ensure_frozen_string_literal(result)
+        result = update_require_paths(result, @target_automation)
+        result = update_page_instantiation(result)
+        result
+      end
+
+      def convert_step(content)
+        result = content.dup
+        result = ensure_frozen_string_literal(result)
+        result = update_require_paths(result, @target_automation)
+        result = update_page_instantiation(result)
+        result
+      end
+
+      private
+
+      def add_page_require(content)
+        return content if content.include?("require_relative '../abstract/page'")
+
+        content.sub(/^(class\s)/, "require_relative '../abstract/page'\n\n\\1")
+      end
+
+      def update_page_instantiation(content)
+        arg = driver_arg_for(@target_automation)
+        if arg
+          swap_driver_arg(content, arg)
+        else
+          remove_driver_arg(content)
+        end
+      end
+    end
+  end
+end

data/lib/adopter/migration_plan.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Adopter
+  class MigrationPlan
+    attr_reader :source_path, :output_path, :target_automation, :target_framework,
+                :ci_platform, :skeleton_structure, :converted_pages, :converted_tests,
+                :converted_features, :converted_steps, :gemfile_additions,
+                :config_overrides, :warnings, :manual_actions
+
+    # :reek:LongParameterList { enabled: false }
+    def initialize(attrs = {})
+      @source_path = attrs[:source_path]
+      @output_path = attrs[:output_path]
+      @target_automation = attrs[:target_automation]
+      @target_framework = attrs[:target_framework]
+      @ci_platform = attrs[:ci_platform]
+      @skeleton_structure = attrs[:skeleton_structure] || {}
+      @converted_pages = attrs[:converted_pages] || []
+      @converted_tests = attrs[:converted_tests] || []
+      @converted_features = attrs[:converted_features] || []
+      @converted_steps = attrs[:converted_steps] || []
+      @gemfile_additions = attrs[:gemfile_additions] || []
+      @config_overrides = attrs[:config_overrides] || {}
+      @warnings = attrs[:warnings] || []
+      @manual_actions = attrs[:manual_actions] || []
+    end
+
+    def to_h
+      {
+        source_path:,
+        output_path:,
+        target_automation:,
+        target_framework:,
+        ci_platform:,
+        skeleton_structure:,
+        converted_pages: converted_pages.map(&:to_h),
+        converted_tests: converted_tests.map(&:to_h),
+        converted_features: converted_features.map(&:to_h),
+        converted_steps: converted_steps.map(&:to_h),
+        gemfile_additions:,
+        config_overrides:,
+        warnings:,
+        manual_actions:
+      }
+    end
+
+    def to_json(*args)
+      require 'json'
+      to_h.to_json(*args)
+    end
+
+    def summary
+      {
+        pages: converted_pages.length,
+        tests: converted_tests.length,
+        features: converted_features.length,
+        steps: converted_steps.length,
+        custom_gems: gemfile_additions.length,
+        warnings: warnings.length,
+        manual_actions: manual_actions.length
+      }
+    end
+  end
+
+  ConvertedFile = Struct.new(:output_path, :content, :source_file, :conversion_notes, keyword_init: true) do
+    def to_h
+      {
+        output_path:,
+        content:,
+        source_file:,
+        conversion_notes:
+      }
+    end
+  end
+end

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