ruby_raider 1.1.4 → 3.0.0

data/lib/scaffolding/templates/page_from_url.tt

@@ -0,0 +1,75 @@
+# 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/page_object.tt

@@ -1,12 +1,61 @@
 # frozen_string_literal: true
 
 require_relative '../abstract/page'
+<%- uses_list.each do |dep| -%>
+require_relative '<%= dep %>'
+<%- end -%>
+<% if nested? -%>
+<% module_parts.each_with_index do |mod, i| -%>
+<%= '  ' * i %>module <%= mod %>
+<% end -%>
+<%= '  ' * module_parts.size %>class <%= NameNormalizer.to_class_name(leaf_name) %>Page < Page
+<%- if project_config['url'] -%>
+<%= '  ' * module_parts.size %>  def url(_page)
+<%= '  ' * module_parts.size %>    '<%= normalized_name %>'
+<%= '  ' * module_parts.size %>  end
+<%- end -%>
 
-class <%= name.split('_').map {|word| word.capitalize }.join %> < Page
+<%= '  ' * module_parts.size %>  # Actions
+<%- if capybara? -%>
+
+<%= '  ' * module_parts.size %>  # Example: fill_in 'field_id', with: value
+<%- else -%>
+
+<%= '  ' * module_parts.size %>  private
+
+<%= '  ' * module_parts.size %>  # Elements
+<%- if selenium? -%>
+<%= '  ' * module_parts.size %>  # Example: driver.find_element(id: 'element_id')
+<%- elsif watir? -%>
+<%= '  ' * module_parts.size %>  # Example: browser.text_field(id: 'element_id')
+<%- end -%>
+<%- end -%>
+<%= '  ' * module_parts.size %>end
+<% module_parts.each_with_index do |_mod, i| -%>
+<%= '  ' * (module_parts.size - i - 1) %>end
+<% end -%>
+<% else -%>
+class <%= page_class_name %> < Page
+<%- if project_config['url'] -%>
+  def url(_page)
+    '<%= normalized_name %>'
+  end
+<%- end -%>
 
   # Actions
+<%- if capybara? -%>
+
+  # Example: fill_in 'field_id', with: value
+<%- else -%>
 
   private
 
   # Elements
+<%- if selenium? -%>
+  # Example: driver.find_element(id: 'element_id')
+<%- elsif watir? -%>
+  # Example: browser.text_field(id: 'element_id')
+<%- end -%>
+<%- end -%>
 end
+<% end -%>

data/lib/scaffolding/templates/spec.tt

@@ -1,4 +1,35 @@
-require_relative '../page_objects/pages/<%= name %>'
+# frozen_string_literal: true
 
-describe '<%= name.split('_').map {|word| word.capitalize }.join %>' do
+require_relative '../page_objects/pages/<%= normalized_name %>'
+<%- uses_list.each do |dep| -%>
+require_relative '../page_objects/pages/<%= dep %>'
+<%- end -%>
+
+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 -%>
+<%- uses_list.each do |dep| -%>
+  let(:<%= dep %>) { <%= NameNormalizer.to_page_class(dep) %>.new<%= selenium? ? '(driver)' : watir? ? '(browser)' : '' %> }
+<%- end -%>
+<%- if project_config['url'] -%>
+
+  before do
+<%- if capybara? -%>
+    visit '<%= normalized_name %>'
+<%- elsif selenium? -%>
+    driver.navigate.to "\#{project_config['url']}/<%= normalized_name %>"
+<%- elsif watir? -%>
+    browser.goto "\#{project_config['url']}/<%= normalized_name %>"
+<%- end -%>
+  end
+<%- end -%>
+
+  it 'loads successfully' do
+    pending 'implement test'
+  end
 end

data/lib/scaffolding/templates/spec_from_page.tt

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

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

data/lib/scaffolding/templates/steps.tt

@@ -1,12 +1,24 @@
 # frozen_string_literal: true
 
-require_relative '../../page_objects/pages/<%= name %>'
+require_relative '../../page_objects/pages/<%= normalized_name %>'
+<%- uses_list.each do |dep| -%>
+require_relative '../../page_objects/pages/<%= dep %>'
+<%- end -%>
 
-Given ('') do
+Given('I am on the <%= normalized_name.tr("_", " ") %> page') do
+<%- if selenium? -%>
+  @page = <%= page_class_name %>.new(driver)
+<%- elsif watir? -%>
+  @page = <%= page_class_name %>.new(browser)
+<%- elsif capybara? -%>
+  visit '<%= normalized_name %>'
+<%- end -%>
 end
 
-When ('') do
+When('I perform an action') do
+  pending 'implement step'
 end
 
-Then ('') do
-end
+Then('I see the expected result') do
+  pending 'implement step'
+end

data/lib/scaffolding/url_analyzer.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'net/http'
+
+class UrlAnalyzer
+  INTERACTIVE_TAGS = %w[input select textarea button].freeze
+
+  attr_reader :url, :page_name, :elements
+
+  def initialize(url, name_override: nil, ai: false) # rubocop:disable Naming/MethodParameterName
+    @url = url
+    @uri = URI.parse(url)
+    @page_name = name_override || derive_page_name
+    @elements = []
+    @ai = ai
+  end
+
+  def analyze
+    html = fetch_html
+    if @ai
+      ai_elements = analyze_with_llm(html)
+      @elements = ai_elements if ai_elements
+    end
+    parse_elements(html) if @elements.empty?
+    self
+  end
+
+  def to_h
+    { page_name: @page_name, url: @url, url_path: @uri.path, elements: @elements }
+  end
+
+  private
+
+  def fetch_html
+    response = Net::HTTP.get_response(@uri)
+    response.body
+  rescue StandardError => e
+    raise "Failed to fetch #{@url}: #{e.message}"
+  end
+
+  def parse_elements(html)
+    # Simple regex-based HTML parsing (no external dependency needed)
+    parse_inputs(html)
+    parse_selects(html)
+    parse_textareas(html)
+    parse_buttons(html)
+    parse_links(html)
+  end
+
+  def parse_inputs(html)
+    html.scan(/<input\s+([^>]*)>/i).each do |match|
+      attrs = parse_attributes(match[0])
+      next if %w[hidden submit].include?(attrs['type'])
+
+      @elements << build_element(
+        name: attrs['name'] || attrs['id'] || attrs['placeholder'] || 'input',
+        type: :input,
+        input_type: attrs['type'] || 'text',
+        locator: best_locator(attrs)
+      )
+    end
+  end
+
+  def parse_selects(html)
+    html.scan(/<select\s+([^>]*)>/i).each do |match|
+      attrs = parse_attributes(match[0])
+      @elements << build_element(
+        name: attrs['name'] || attrs['id'] || 'select',
+        type: :select,
+        locator: best_locator(attrs)
+      )
+    end
+  end
+
+  def parse_textareas(html)
+    html.scan(/<textarea\s+([^>]*)>/i).each do |match|
+      attrs = parse_attributes(match[0])
+      @elements << build_element(
+        name: attrs['name'] || attrs['id'] || 'textarea',
+        type: :textarea,
+        locator: best_locator(attrs)
+      )
+    end
+  end
+
+  def parse_buttons(html)
+    html.scan(%r{<button\s+([^>]*)>([^<]*)</button>}i).each do |match|
+      attrs = parse_attributes(match[0])
+      text = match[1].strip
+      @elements << build_element(
+        name: attrs['id'] || attrs['name'] || text.downcase.gsub(/\s+/, '_') || 'button',
+        type: :button,
+        text:,
+        locator: best_locator(attrs, text:)
+      )
+    end
+
+    html.scan(/<input\s+([^>]*type=["']submit["'][^>]*)>/i).each do |match|
+      attrs = parse_attributes(match[0])
+      @elements << build_element(
+        name: attrs['id'] || attrs['name'] || attrs['value']&.downcase&.gsub(/\s+/, '_') || 'submit',
+        type: :submit,
+        text: attrs['value'] || 'Submit',
+        locator: best_locator(attrs)
+      )
+    end
+  end
+
+  def parse_links(html)
+    html.scan(%r{<a\s+([^>]*)>([^<]*)</a>}i).first(5)&.each do |match|
+      attrs = parse_attributes(match[0])
+      text = match[1].strip
+      next if text.empty?
+
+      @elements << build_element(
+        name: text.downcase.gsub(/\s+/, '_'),
+        type: :link,
+        text:,
+        locator: best_locator(attrs, text:)
+      )
+    end
+  end
+
+  def parse_attributes(attr_string)
+    attrs = {}
+    attr_string.scan(/([\w-]+)=["']([^"']*)["']/).each do |key, value|
+      attrs[key] = value
+    end
+    attrs
+  end
+
+  def best_locator(attrs, text: nil)
+    if attrs['id']
+      { type: :id, value: attrs['id'] }
+    elsif attrs['name']
+      { type: :name, value: attrs['name'] }
+    elsif attrs['class'] && !attrs['class'].empty?
+      { type: :css, value: ".#{attrs['class'].split.first}" }
+    elsif text && !text.empty?
+      { type: :xpath, value: "//#{infer_tag(attrs)}[contains(text(), '#{text}')]" }
+    else
+      { type: :css, value: attrs.first&.last || 'unknown' }
+    end
+  end
+
+  def infer_tag(attrs)
+    return 'button' if attrs['type'] == 'button' || attrs['type'] == 'submit'
+    return 'a' if attrs['href']
+
+    '*'
+  end
+
+  def build_element(name:, type:, locator:, **extra)
+    clean_name = name.to_s.gsub(/[^a-z0-9_]/i, '_').gsub(/_+/, '_').downcase.delete_prefix('_').delete_suffix('_')
+    { name: clean_name, type:, locator: }.merge(extra)
+  end
+
+  def analyze_with_llm(html)
+    require_relative '../llm/client'
+    require_relative '../llm/prompts'
+    require_relative '../llm/response_parser'
+
+    return nil unless Llm::Client.available?
+
+    response = Llm::Client.complete(
+      Llm::Prompts.analyze_page(html, @url),
+      system_prompt: Llm::Prompts.system_prompt
+    )
+    Llm::ResponseParser.extract_elements(response)
+  end
+
+  def derive_page_name
+    path = @uri.path.to_s.gsub(%r{^/|/$}, '')
+    return 'home' if path.empty?
+
+    path.split('/').last.gsub(/[^a-z0-9]/i, '_').downcase
+  end
+end

data/lib/utilities/desktop_downloader.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+require 'rbconfig'
+
+# Downloads the latest Raider Desktop release for the current platform.
+# Uses the GitHub API to discover the latest release and match the right artifact.
+module DesktopDownloader
+  REPO = 'RaiderHQ/raider_desktop'
+  API_URL = "https://api.github.com/repos/#{REPO}/releases/latest".freeze
+
+  PLATFORM_PATTERNS = {
+    'mac_arm' => /\.dmg$/i,
+    'mac_intel' => /\.dmg$/i,
+    'windows' => /setup\.exe$/i,
+    'linux_deb' => /\.deb$/i,
+    'linux_appimage' => /\.AppImage$/i
+  }.freeze
+
+  HTTP_OPEN_TIMEOUT = 10
+  HTTP_READ_TIMEOUT = 15
+
+  class << self
+    def download(destination_dir = nil)
+      destination_dir ||= default_download_dir
+      asset = find_asset
+      unless asset
+        warn '[Ruby Raider] No desktop release found for your platform'
+        return nil
+      end
+
+      destination = File.join(destination_dir, asset[:name])
+      puts "Downloading Raider Desktop (#{asset[:name]})..."
+      download_file(asset[:url], destination)
+      puts "Downloaded to: #{destination}"
+      destination
+    end
+
+    def latest_version
+      cached_release&.dig('tag_name')
+    end
+
+    def download_url
+      asset = find_asset
+      asset&.dig(:url)
+    end
+
+    # Clear cached release data (useful between operations or for testing)
+    def clear_cache
+      @cached_release = :unset
+    end
+
+    def platform
+      host_os = RbConfig::CONFIG['host_os']
+      arch = RbConfig::CONFIG['host_cpu']
+
+      case host_os
+      when /darwin|mac os/i
+        arch =~ /arm|aarch64/i ? 'mac_arm' : 'mac_intel'
+      when /mswin|mingw|cygwin|windows/i
+        'windows'
+      when /linux/i
+        'linux_appimage'
+      else
+        'linux_appimage'
+      end
+    end
+
+    def platform_display_name
+      case platform
+      when 'mac_arm' then 'macOS (Apple Silicon)'
+      when 'mac_intel' then 'macOS (Intel)'
+      when 'windows' then 'Windows'
+      when 'linux_deb' then 'Linux (deb)'
+      when 'linux_appimage' then 'Linux (AppImage)'
+      else 'Unknown'
+      end
+    end
+
+    private
+
+    def find_asset
+      release = cached_release
+      return nil unless release
+
+      assets = release['assets'] || []
+      pattern = PLATFORM_PATTERNS[platform]
+      return nil unless pattern
+
+      matched = assets.find { |a| a['name'].match?(pattern) }
+      return nil unless matched
+
+      { name: matched['name'], url: matched['browser_download_url'], size: matched['size'] }
+    end
+
+    # Cache release data to avoid duplicate GitHub API calls
+    # (latest_version, find_asset, and download_url all need the same data)
+    def cached_release
+      return @cached_release if defined?(@cached_release) && @cached_release != :unset
+
+      @cached_release = fetch_latest_release
+    end
+
+    def fetch_latest_release
+      uri = URI(API_URL)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == 'https'
+      http.open_timeout = HTTP_OPEN_TIMEOUT
+      http.read_timeout = HTTP_READ_TIMEOUT
+      response = http.get(uri.request_uri)
+      return nil unless response.is_a?(Net::HTTPSuccess)
+
+      JSON.parse(response.body)
+    rescue Net::OpenTimeout, Net::ReadTimeout => e
+      warn "[Ruby Raider] GitHub API timed out: #{e.message}"
+      nil
+    rescue StandardError => e
+      warn "[Ruby Raider] Failed to check releases: #{e.message}"
+      nil
+    end
+
+    def download_file(url, destination)
+      FileUtils.mkdir_p(File.dirname(destination))
+      uri = URI(url)
+      follow_redirects(uri, destination)
+    end
+
+    def follow_redirects(uri, destination, limit = 5)
+      raise 'Too many redirects' if limit.zero?
+
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https',
+                                          open_timeout: HTTP_OPEN_TIMEOUT, read_timeout: 60) do |http|
+        request = Net::HTTP::Get.new(uri)
+        http.request(request) do |response|
+          case response
+          when Net::HTTPRedirection
+            follow_redirects(URI(response['location']), destination, limit - 1)
+          when Net::HTTPSuccess
+            write_response(response, destination)
+          else
+            raise "Download failed: #{response.code} #{response.message}"
+          end
+        end
+      end
+    end
+
+    def write_response(response, destination)
+      total = response['content-length']&.to_i
+      downloaded = 0
+      File.open(destination, 'wb') do |file|
+        response.read_body do |chunk|
+          file.write(chunk)
+          downloaded += chunk.size
+          print_progress(downloaded, total) if total&.positive?
+        end
+      end
+      puts
+    end
+
+    def print_progress(downloaded, total)
+      percent = (downloaded * 100.0 / total).round(1)
+      bar_width = 30
+      filled = (percent / 100.0 * bar_width).round
+      bar = "#{'=' * filled}#{' ' * (bar_width - filled)}"
+      mb = (downloaded / 1_048_576.0).round(1)
+      total_mb = (total / 1_048_576.0).round(1)
+      print "\r  [#{bar}] #{percent}% (#{mb}/#{total_mb} MB)"
+    end
+
+    def default_download_dir
+      downloads = File.expand_path('~/Downloads')
+      File.directory?(downloads) ? downloads : Dir.pwd
+    end
+  end
+end