ruby_raider 3.0.1 → 3.2.0

data/lib/llm/providers/openai_provider.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../provider'
-
-module Llm
-  module Providers
-    class OpenaiProvider < Provider
-      DEFAULT_MODEL = 'gpt-4o-mini'
-
-      def initialize(api_key:, model: nil)
-        super()
-        @api_key = api_key
-        @model = model || DEFAULT_MODEL
-      end
-
-      def complete(prompt, system_prompt: nil)
-        client = build_client
-        messages = build_messages(prompt, system_prompt)
-        response = client.chat(parameters: { model: @model, messages:, temperature: 0.2 })
-        response.dig('choices', 0, 'message', 'content')
-      rescue StandardError => e
-        warn "[Ruby Raider] OpenAI error: #{e.message}"
-        nil
-      end
-
-      def available?
-        require 'openai'
-        !@api_key.nil? && !@api_key.empty?
-      rescue LoadError
-        warn '[Ruby Raider] Install ruby-openai gem: gem install ruby-openai'
-        false
-      end
-
-      private
-
-      def build_client
-        require 'openai'
-        OpenAI::Client.new(access_token: @api_key)
-      end
-    end
-  end
-end

data/lib/llm/response_parser.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module Llm
-  # Extracts JSON from LLM responses, handling markdown wrapping and malformed output.
-  # Returns nil on parse failure — callers should fall back to non-AI path.
-  module ResponseParser
-    module_function
-
-    def parse_json(response)
-      return nil if response.nil? || response.strip.empty?
-
-      json_str = extract_json(response)
-      result = JSON.parse(json_str, symbolize_names: true)
-      result.is_a?(Hash) ? result : nil
-    rescue JSON::ParserError
-      nil
-    end
-
-    def extract_elements(response)
-      parsed = parse_json(response)
-      return nil unless parsed && parsed[:elements].is_a?(Array)
-
-      parsed[:elements].map { |el| normalize_element(el) }.compact
-    end
-
-    def extract_scenarios(response)
-      parsed = parse_json(response)
-      return nil unless parsed && parsed[:scenarios].is_a?(Array)
-
-      parsed[:scenarios]
-    end
-
-    def normalize_element(element)
-      return nil unless element[:name] && element[:type] && element[:locator]
-
-      locator = element[:locator]
-      locator = { type: locator[:type]&.to_sym, value: locator[:value] } if locator.is_a?(Hash)
-
-      {
-        name: element[:name].to_s.gsub(/[^a-z0-9_]/i, '_').downcase,
-        type: element[:type].to_sym,
-        locator:,
-        purpose: element[:purpose],
-        input_type: element[:input_type],
-        text: element[:text]
-      }.compact
-    end
-
-    def extract_json(text)
-      # Try raw JSON first
-      stripped = text.strip
-      return stripped if stripped.start_with?('{')
-
-      # Try markdown code block
-      match = text.match(/```(?:json)?\s*\n?(.*?)\n?\s*```/m)
-      return match[1].strip if match
-
-      # Try finding first { ... } block
-      brace_match = text.match(/(\{.*\})/m)
-      return brace_match[1] if brace_match
-
-      text
-    end
-  end
-end

data/lib/plugin/plugin.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-require_relative 'plugin_exposer'
-
-module RubyRaider
-  module Plugin
-    class << self
-      def add_plugin(plugin_name)
-        return gemfile_guard unless File.exist?('Gemfile')
-        return pp 'The plugin was not found' unless available?(plugin_name)
-        return pp 'The plugin is already installed' if installed?(plugin_name)
-
-        pp "Adding #{plugin_name}..."
-        add_plugin_to_gemfile(plugin_name)
-        invalidate_gemfile_cache
-        system('bundle install')
-        PluginExposer.expose_commands(plugin_name)
-        pp "The plugin #{plugin_name} is added"
-      end
-
-      def delete_plugin(plugin_name)
-        return gemfile_guard unless File.exist?('Gemfile')
-        return 'The plugin is not installed' unless installed_plugins.include?(plugin_name)
-
-        pp "Deleting #{plugin_name}..."
-        remove_plugin_from_gemfile(plugin_name)
-        invalidate_gemfile_cache
-        PluginExposer.remove_command(plugin_name)
-        system('bundle install')
-        pp "The plugin #{plugin_name} is deleted"
-      end
-
-      def installed_plugins
-        return gemfile_guard unless File.exist?('Gemfile')
-
-        cached_gemfile_lines.filter_map do |line|
-          stripped = line.sub('gem ', '').strip.delete("'")
-          stripped if plugins.include?(stripped)
-        end
-      end
-
-      def installed?(plugin_name)
-        installed_plugins.include?(plugin_name)
-      end
-
-      def available?(plugin_name)
-        plugins.include?(plugin_name)
-      end
-
-      def camelize(str)
-        str.split('_').collect(&:capitalize).join
-      end
-
-      def plugins
-        ['great_axe']
-      end
-
-      private
-
-      # Read Gemfile once and cache until explicitly invalidated
-      def cached_gemfile_lines
-        @cached_gemfile_lines ||= File.readlines('Gemfile')
-      end
-
-      def invalidate_gemfile_cache
-        @cached_gemfile_lines = nil
-      end
-
-      def add_plugin_to_gemfile(plugin_name)
-        return gemfile_guard unless File.exist?('Gemfile')
-
-        lines = cached_gemfile_lines
-        has_comment = lines.any? { |l| l.include?('Ruby Raider Plugins') }
-        has_plugin = lines.any? { |l| l.include?(plugin_name) }
-
-        File.open('Gemfile', 'a') do |file|
-          file.puts "\n# Ruby Raider Plugins\n" unless has_comment
-          file.puts "gem '#{plugin_name}'" unless has_plugin
-        end
-      end
-
-      def remove_plugin_from_gemfile(plugin_name)
-        output_lines = remove_plugins_and_comments(plugin_name)
-        update_gemfile(output_lines)
-      end
-
-      def last_plugin?
-        installed_plugins.count == 1
-      end
-
-      def remove_plugins_and_comments(plugin_name)
-        cached_gemfile_lines.reject do |line|
-          line.include?(plugin_name) || line.include?('Ruby Raider Plugins') && last_plugin?
-        end
-      end
-
-      def update_gemfile(output_lines)
-        return gemfile_guard unless File.exist?('Gemfile')
-
-        File.open('Gemfile', 'w') do |file|
-          output_lines.each { |line| file.puts line }
-        end
-      end
-
-      def gemfile_guard
-        pp 'There is no Gemfile, please create one to install plugins'
-      end
-    end
-  end
-end

data/lib/plugin/plugin_exposer.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../plugin/plugin'
-
-module RubyRaider
-  module PluginExposer
-    class << self
-      FILE_PATH = File.expand_path('../commands/loaded_commands.rb', __dir__)
-      def expose_commands(plugin_name)
-        commands = read_loaded_commands
-        return pp 'The plugin is already installed' if commands.any? { |l| l.include?(plugin_name) }
-
-        has_subcommands = commands.any? { |l| l.include?('subcommand') }
-
-        File.open(FILE_PATH, 'w') do |file|
-          commands.each do |line|
-            file.puts line
-            file.puts "require '#{plugin_name}'" if line.include?("require 'thor'")
-            if line.strip == 'class LoadedCommands < Thor' && !has_subcommands
-              file.puts formatted_command_without_space(plugin_name)
-            elsif line.strip == 'class LoadedCommands < Thor' && has_subcommands
-              file.puts formatted_command_with_space(plugin_name)
-            end
-          end
-        end
-      end
-
-      def remove_command(plugin_name)
-        commands = read_loaded_commands
-        return pp 'The plugin is not installed' unless commands.any? { |l| l.include?(plugin_name) }
-
-        output_lines = commands.reject { |line| line.include?(plugin_name) }
-
-        File.open(FILE_PATH, 'w') do |file|
-          output_lines.each { |line| file.puts line }
-        end
-      end
-
-      private
-
-      def read_loaded_commands
-        File.readlines(FILE_PATH)
-      end
-
-      def formatted_command_without_space(plugin_name)
-        "desc '#{plugin_name}', 'Provides access to all the commands for #{plugin_name}'\n" \
-        "subcommand '#{plugin_name}', #{Plugin.camelize(plugin_name)}::PluginCommands"
-      end
-
-      def formatted_command_with_space(plugin_name)
-        "\n#{formatted_command_without_space(plugin_name)}"
-      end
-    end
-  end
-end

data/lib/scaffolding/crud_generator.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'name_normalizer'
-
-class CrudGenerator
-  ACTIONS = %w[list create detail edit].freeze
-
-  def initialize(base_name, scaffolding_class, config_loader)
-    @base_name = NameNormalizer.normalize(base_name)
-    @scaffolding_class = scaffolding_class
-    @config_loader = config_loader
-  end
-
-  def generate
-    generated = []
-    ACTIONS.each do |action|
-      name = "#{@base_name}_#{action}"
-      generate_page(name)
-      generate_test(name)
-      generated << name
-    end
-    generate_model
-    generated
-  end
-
-  def planned_files
-    files = []
-    ACTIONS.each do |action|
-      name = "#{@base_name}_#{action}"
-      files << "page_objects/pages/#{name}.rb"
-      files << test_path(name)
-    end
-    files << "models/data/#{@base_name}.yml"
-    files
-  end
-
-  private
-
-  def generate_page(name)
-    path = @config_loader.call('page')
-    @scaffolding_class.new([name, path]).generate_page
-  end
-
-  def generate_test(name)
-    if Dir.exist?('features')
-      path = @config_loader.call('feature')
-      @scaffolding_class.new([name, path]).generate_feature
-      path = @config_loader.call('steps')
-      @scaffolding_class.new([name, path]).generate_steps
-    elsif Dir.exist?('test')
-      path = @config_loader.call('spec')
-      @scaffolding_class.new([name, path]).generate_spec
-    else
-      path = @config_loader.call('spec')
-      @scaffolding_class.new([name, path]).generate_spec
-    end
-  end
-
-  def generate_model
-    model_path = "models/data/#{@base_name}.yml"
-    return if File.exist?(model_path)
-
-    FileUtils.mkdir_p(File.dirname(model_path))
-    File.write(model_path, model_content)
-  end
-
-  def model_content
-    <<~YAML
-      # Data model for #{@base_name}
-      # Used with ModelFactory for test data generation
-      default:
-        name: 'Test #{@base_name.capitalize}'
-        email: 'test@example.com'
-
-      valid:
-        name: 'Valid #{@base_name.capitalize}'
-        email: 'valid@example.com'
-
-      invalid:
-        name: ''
-        email: 'invalid'
-    YAML
-  end
-
-  def test_path(name)
-    if Dir.exist?('features')
-      "features/#{name}.feature"
-    elsif Dir.exist?('test')
-      "test/test_#{name}.rb"
-    else
-      "spec/#{name}_page_spec.rb"
-    end
-  end
-end

data/lib/scaffolding/dry_run_presenter.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module DryRunPresenter
-  module_function
-
-  def preview(planned_files)
-    return [] if planned_files.empty?
-
-    puts '[dry-run] Would create:'
-    planned_files.each do |file|
-      puts "  #{file}"
-    end
-    puts ''
-    planned_files
-  end
-end

data/lib/scaffolding/page_introspector.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'ripper'
-
-class PageIntrospector
-  SKIP_METHODS = %w[initialize url to_s inspect].freeze
-
-  attr_reader :class_name, :methods
-
-  def initialize(file_path)
-    @source = File.read(file_path)
-    @class_name = extract_class_name
-    @methods = extract_public_methods
-  end
-
-  private
-
-  def extract_class_name
-    match = @source.match(/class\s+(\w+)/)
-    match ? match[1] : 'UnknownPage'
-  end
-
-  def extract_public_methods
-    in_private = false
-    results = []
-
-    @source.each_line do |line|
-      stripped = line.strip
-      in_private = true if stripped.match?(/^\s*(private|protected)\s*$/)
-      next if in_private
-
-      match = stripped.match(/^\s*def\s+(\w+)(\(([^)]*)\))?/)
-      next unless match
-
-      method_name = match[1]
-      next if SKIP_METHODS.include?(method_name)
-      next if method_name.start_with?('_')
-
-      params = match[3]&.split(',')&.map(&:strip) || []
-      results << { name: method_name, params: }
-    end
-
-    results
-  end
-end

data/lib/scaffolding/scaffold_menu.rb

@@ -1,103 +0,0 @@
-# frozen_string_literal: true
-
-require 'tty-prompt'
-require_relative 'project_detector'
-
-class ScaffoldMenu
-  COMPONENTS = {
-    'Page object' => :page,
-    'Spec (RSpec)' => :spec,
-    'Feature (Cucumber)' => :feature,
-    'Steps (Cucumber)' => :steps,
-    'Helper' => :helper,
-    'Component' => :component,
-    'Model data' => :model
-  }.freeze
-
-  def initialize
-    @prompt = TTY::Prompt.new
-  end
-
-  def run
-    names = ask_names
-    components = ask_components
-    uses = ask_relationships
-    preview_and_confirm(names, components, uses)
-  end
-
-  # Programmatic entry point for raider_desktop
-  def self.build_options(names:, components:, uses: [])
-    { names: Array(names), components: Array(components), uses: Array(uses) }
-  end
-
-  private
-
-  def ask_names
-    input = @prompt.ask('Enter scaffold name(s), comma-separated:') do |q|
-      q.required true
-    end
-    input.split(',').map(&:strip).reject(&:empty?)
-  end
-
-  def ask_components
-    project = ScaffoldProjectDetector.detect
-    defaults = default_components(project)
-
-    @prompt.multi_select('Select components to generate:', default: defaults) do |menu|
-      COMPONENTS.each do |label, value|
-        menu.choice label, value
-      end
-    end
-  end
-
-  def ask_relationships
-    return [] unless @prompt.yes?('Add page dependencies (--uses)?', default: false)
-
-    pages = Dir.glob('page_objects/pages/*.rb').map { |f| File.basename(f, '.rb') }
-    return [] if pages.empty?
-
-    @prompt.multi_select('Select dependent pages:', pages)
-  end
-
-  def preview_and_confirm(names, components, uses)
-    files = planned_files(names, components)
-
-    @prompt.say("\nWill create:")
-    files.each { |f| @prompt.say("  #{f}") }
-    @prompt.say('')
-
-    return nil unless @prompt.yes?('Proceed?')
-
-    { names:, components:, uses: }
-  end
-
-  def planned_files(names, components)
-    names.flat_map do |name|
-      components.map { |comp| file_for(name, comp) }
-    end
-  end
-
-  def file_for(name, component)
-    case component
-    when :page then "page_objects/pages/#{name}.rb"
-    when :spec then "spec/#{name}_page_spec.rb"
-    when :feature then "features/#{name}.feature"
-    when :steps then "features/step_definitions/#{name}_steps.rb"
-    when :helper then "helpers/#{name}_helper.rb"
-    when :component then "page_objects/components/#{name}.rb"
-    when :model then "models/data/#{name}.yml"
-    end
-  end
-
-  def default_components(project)
-    defaults = [:page]
-    if project[:has_features]
-      defaults += %i[feature steps]
-    elsif project[:has_test]
-      defaults << :spec
-    else
-      defaults << :spec
-    end
-    defaults.map { |d| COMPONENTS.key(d) }.compact
-  end
-end

data/lib/scaffolding/templates/page_from_url.tt

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../abstract/page'
-
-class <%= page_class_name %> < Page
-  def url(_page)
-    '<%= url_data[:url_path] %>'
-  end
-
-  # Actions
-<%- form_elements = url_data[:elements].select { |e| %i[input textarea select].include?(e[:type]) } -%>
-<%- button_elements = url_data[:elements].select { |e| %i[button submit].include?(e[:type]) } -%>
-<%- unless form_elements.empty? -%>
-
-<%- if capybara? -%>
-  def fill_form(<%= form_elements.map { |e| e[:name] }.join(', ') %>)
-<%- form_elements.each do |el| -%>
-<%- if el[:locator][:type] == :id -%>
-    fill_in '<%= el[:locator][:value] %>', with: <%= el[:name] %>
-<%- elsif el[:locator][:type] == :name -%>
-    fill_in '<%= el[:locator][:value] %>', with: <%= el[:name] %>
-<%- else -%>
-    find('<%= el[:locator][:value] %>').set(<%= el[:name] %>)
-<%- end -%>
-<%- end -%>
-  end
-<%- else -%>
-  def fill_form(<%= form_elements.map { |e| e[:name] }.join(', ') %>)
-<%- form_elements.each do |el| -%>
-    <%= el[:name] %>_field.<%= selenium? ? 'send_keys' : 'set' %> <%= el[:name] %>
-<%- end -%>
-  end
-<%- end -%>
-<%- end -%>
-<%- unless button_elements.empty? -%>
-
-<%- button_elements.each do |el| -%>
-<%- if capybara? -%>
-  def click_<%= el[:name] %>
-    click_button '<%= el[:text] || el[:name] %>'
-  end
-<%- else -%>
-  def click_<%= el[:name] %>
-    <%= el[:name] %>_button.click
-  end
-<%- end -%>
-<%- end -%>
-<%- end -%>
-<%- unless capybara? -%>
-
-  private
-
-  # Elements
-<%- form_elements.each do |el| -%>
-
-  def <%= el[:name] %>_field
-<%- if selenium? -%>
-    driver.find_element(<%= el[:locator][:type] %>: '<%= el[:locator][:value] %>')
-<%- elsif watir? -%>
-    browser.<%= el[:type] == :select ? 'select' : 'text_field' %>(<%= el[:locator][:type] %>: '<%= el[:locator][:value] %>')
-<%- end -%>
-  end
-<%- end -%>
-<%- button_elements.each do |el| -%>
-
-  def <%= el[:name] %>_button
-<%- if selenium? -%>
-    driver.find_element(<%= el[:locator][:type] %>: '<%= el[:locator][:value] %>')
-<%- elsif watir? -%>
-    browser.button(<%= el[:locator][:type] %>: '<%= el[:locator][:value] %>')
-<%- end -%>
-  end
-<%- end -%>
-<%- end -%>
-end

data/lib/scaffolding/templates/spec_from_page.tt

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../page_objects/pages/<%= normalized_name %>'
-
-describe '<%= introspected.class_name %>' do
-<%- if selenium? -%>
-  let(:page) { <%= introspected.class_name %>.new(driver) }
-<%- elsif watir? -%>
-  let(:page) { <%= introspected.class_name %>.new(browser) }
-<%- elsif capybara? -%>
-  let(:page) { <%= introspected.class_name %>.new }
-<%- end -%>
-<%- introspected.methods.each do |method| -%>
-<%- scenario = ai_scenarios[method[:name]] -%>
-
-  describe '#<%= method[:name] %>' do
-    it '<%= scenario ? scenario[:description] : method[:name].tr("_", " ") %>' do
-<%- if method[:params].empty? -%>
-      page.<%= method[:name] %>
-<%- else -%>
-      page.<%= method[:name] %>(<%= method[:params].map { |p| "'#{p}'" }.join(', ') %>)
-<%- end -%>
-<%- if scenario && scenario[:assertion_hint] -%>
-      pending '<%= scenario[:assertion_hint] %>'
-<%- else -%>
-      pending 'add assertions'
-<%- end -%>
-    end
-  end
-<%- end -%>
-end

data/lib/scaffolding/templates/spec_from_url.tt

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../page_objects/pages/<%= normalized_name %>'
-
-describe '<%= page_class_name %>' do
-<%- if selenium? -%>
-  let(:page) { <%= page_class_name %>.new(driver) }
-<%- elsif watir? -%>
-  let(:page) { <%= page_class_name %>.new(browser) }
-<%- elsif capybara? -%>
-  let(:page) { <%= page_class_name %>.new }
-<%- end -%>
-
-  before do
-<%- if capybara? -%>
-    visit '<%= url_data[:url_path] %>'
-<%- elsif selenium? -%>
-    driver.navigate.to '<%= url_data[:url] %>'
-<%- elsif watir? -%>
-    browser.goto '<%= url_data[:url] %>'
-<%- end -%>
-  end
-<%- form_elements = url_data[:elements].select { |e| %i[input textarea select].include?(e[:type]) } -%>
-<%- unless form_elements.empty? -%>
-
-  describe '#fill_form' do
-    it 'fills in the form fields' do
-      page.fill_form(<%= form_elements.map { |e| "'test_#{e[:name]}'" }.join(', ') %>)
-      pending 'add assertions'
-    end
-  end
-<%- end -%>
-<%- url_data[:elements].select { |e| %i[button submit].include?(e[:type]) }.each do |el| -%>
-
-  describe '#click_<%= el[:name] %>' do
-    it 'clicks the <%= el[:name].tr("_", " ") %> button' do
-      page.click_<%= el[:name] %>
-      pending 'add assertions'
-    end
-  end
-<%- end -%>
-
-  it 'loads the page' do
-    pending 'add assertions'
-  end
-end