capydash 0.2.0 → 0.2.2

data/lib/capydash/engine.rb

@@ -1,52 +0,0 @@
-module CapyDash
-  class Engine < ::Rails::Engine
-    isolate_namespace CapyDash
-
-    rake_tasks do
-      load File.expand_path("../tasks/capydash.rake", __dir__)
-    end
-
-    initializer "capydash.configuration", before: :load_config_initializers do
-      # Load configuration
-      CapyDash.config = CapyDash::Configuration.load_from_file
-      CapyDash::Logger.setup(CapyDash.config)
-
-      CapyDash::Logger.info("CapyDash configuration loaded", {
-        server_port: CapyDash.config.server_port,
-        log_level: CapyDash.config.log_level,
-        auth_enabled: CapyDash.config.auth_enabled?
-      })
-    end
-
-    initializer "capydash.instrumentation", after: :load_config_initializers do
-      begin
-        # Hook into Capybara sessions automatically
-        ActiveSupport.on_load(:action_dispatch_integration_test) do
-          Capybara::Session.include(CapyDash::Instrumentation)
-        end
-
-        # Start WebSocket server automatically in dev/test unless using external WS
-        if (Rails.env.development? || Rails.env.test?) && ENV["CAPYDASH_EXTERNAL_WS"] != "1"
-          port = CapyDash.config.server_port
-          CapyDash::DashboardServer.instance(port: port).start
-
-          CapyDash::Logger.info("WebSocket server started", {
-            port: port,
-            environment: Rails.env
-          })
-        else
-          CapyDash::Logger.info("Skipping in-process WebSocket server", {
-            reason: ENV["CAPYDASH_EXTERNAL_WS"] == "1" ? "external_mode" : "production_environment",
-            environment: Rails.env
-          })
-        end
-      rescue => e
-        CapyDash::ErrorHandler.handle_error(e, {
-          error_type: 'initialization',
-          component: 'engine'
-        })
-        raise
-      end
-    end
-  end
-end

data/lib/capydash/error_handler.rb

@@ -1,101 +0,0 @@
-module CapyDash
-  class ErrorHandler
-    class << self
-      def handle_error(error, context = {})
-        log_error(error, context)
-        notify_error(error, context) if should_notify?(error)
-        recover_from_error(error, context)
-      end
-
-      def handle_websocket_error(error, connection = nil)
-        context = {
-          error_type: 'websocket',
-          connection_id: connection&.id,
-          error_class: error.class.name
-        }
-        handle_error(error, context)
-      end
-
-      def handle_test_execution_error(error, test_path = nil)
-        context = {
-          error_type: 'test_execution',
-          test_path: test_path,
-          error_class: error.class.name
-        }
-        handle_error(error, context)
-      end
-
-      def handle_instrumentation_error(error, method_name = nil)
-        context = {
-          error_type: 'instrumentation',
-          method_name: method_name,
-          error_class: error.class.name
-        }
-        handle_error(error, context)
-      end
-
-      private
-
-      def log_error(error, context)
-        Logger.error(
-          "Error occurred: #{error.message}",
-          context.merge(
-            backtrace: error.backtrace&.first(5),
-            error_class: error.class.name
-          )
-        )
-      end
-
-      def notify_error(error, context)
-        # In a production app, this would send notifications to monitoring services
-        # like Sentry, Bugsnag, or custom webhooks
-        puts "🚨 CRITICAL ERROR: #{error.message}"
-        puts "Context: #{context}"
-      end
-
-      def should_notify?(error)
-        # Only notify for critical errors
-        error.is_a?(StandardError) &&
-        !error.is_a?(ArgumentError) &&
-        !error.is_a?(NoMethodError)
-      end
-
-      def recover_from_error(error, context)
-        case context[:error_type]
-        when 'websocket'
-          recover_websocket_connection
-        when 'test_execution'
-          recover_test_execution
-        when 'instrumentation'
-          recover_instrumentation
-        else
-          # Generic recovery
-          Logger.warn("No specific recovery strategy for error type: #{context[:error_type]}")
-        end
-      end
-
-      def recover_websocket_connection
-        Logger.info("Attempting to recover WebSocket connection")
-        # In a real implementation, this would attempt to reconnect
-        # or notify the dashboard to refresh the connection
-      end
-
-      def recover_test_execution
-        Logger.info("Test execution error recovered")
-        # Could implement retry logic or cleanup
-      end
-
-      def recover_instrumentation
-        Logger.info("Instrumentation error recovered")
-        # Could disable problematic instrumentation or use fallbacks
-      end
-    end
-  end
-
-  # Custom error classes for better error handling
-  class CapyDashError < StandardError; end
-  class ConfigurationError < CapyDashError; end
-  class WebSocketError < CapyDashError; end
-  class TestExecutionError < CapyDashError; end
-  class InstrumentationError < CapyDashError; end
-end

data/lib/capydash/event_emitter.rb

@@ -1,29 +0,0 @@
-require 'capydash/dashboard_server'
-require 'capydash/forwarder'
-
-module CapyDash
-  module EventEmitter
-    @clients = []
-
-    class << self
-      attr_accessor :clients
-
-      def subscribe(&block)
-        @on_event = block
-      end
-
-      def broadcast(event)
-        @on_event&.call(event)
-
-        port = CapyDash.configuration&.port
-        if ENV["CAPYDASH_EXTERNAL_WS"] == "1"
-          forwarder = CapyDash::Forwarder.instance(port: port)
-          forwarder.send_message(event)
-        else
-          server = CapyDash::DashboardServer.instance(port: port)
-          server.broadcast(event.to_json)
-        end
-      end
-    end
-  end
-end

data/lib/capydash/forwarder.rb

@@ -1,78 +0,0 @@
-require 'eventmachine'
-require 'faye/websocket'
-require 'json'
-
-module CapyDash
-  # Forwards events to an external WebSocket server when CAPYDASH_EXTERNAL_WS=1
-  class Forwarder
-    attr_reader :port
-
-    def self.instance(port: nil)
-      configured_port = port || (CapyDash.respond_to?(:configuration) ? CapyDash.configuration&.port : nil)
-      @instance ||= new(port: configured_port || 4000)
-    end
-
-    def initialize(port: 4000)
-      @port = port
-      @connected = false
-      @queue = []
-      @ws = nil
-      @mutex = Mutex.new
-      start
-    end
-
-    def start
-      return if @started
-      @started = true
-
-      Thread.new do
-        EM.run do
-          connect
-        end
-      end
-    end
-
-    def connect
-      url = "ws://127.0.0.1:#{@port}"
-      @ws = Faye::WebSocket::Client.new(url)
-
-      @ws.on(:open) do |_event|
-        @connected = true
-        flush_queue
-      end
-
-      @ws.on(:close) do |_event|
-        @connected = false
-        # attempt reconnect after short delay
-        EM.add_timer(0.5) { connect }
-      end
-
-      @ws.on(:error) do |event|
-        # keep trying; errors are expected if server not yet up
-      end
-    end
-
-    def send_message(raw_message)
-      message = raw_message.is_a?(String) ? raw_message : JSON.dump(raw_message)
-      @mutex.synchronize do
-        if @connected && @ws
-          @ws.send(message)
-        else
-          @queue << message
-        end
-      end
-    end
-
-    private
-
-    def flush_queue
-      return unless @connected && @ws
-      pending = nil
-      @mutex.synchronize do
-        pending = @queue.dup
-        @queue.clear
-      end
-      pending.each { |m| @ws.send(m) }
-    end
-  end
-end

data/lib/capydash/instrumentation.rb

@@ -1,153 +0,0 @@
-require 'capybara'
-require 'capydash/dashboard_server'
-require 'base64'
-require 'fileutils'
-
-module CapyDash
-  module Instrumentation
-    def visit(path)
-      emit_step("visit", path) { super(path) }
-    end
-
-    def click_button(*args)
-      emit_step("click_button", args.first) { super(*args) }
-    end
-
-    def fill_in(locator, with:)
-      emit_step("fill_in", "#{locator} => #{with}") { super(locator, with: with) }
-    end
-
-    private
-
-    def emit_step(step_name, detail)
-      # emit "running" event first (without screenshot)
-      CapyDash::EventEmitter.broadcast(
-        step_name: step_name,
-        detail: detail,
-        test_name: (defined?(CapyDash) ? CapyDash.current_test : nil),
-        status: "running"
-      )
-
-      # run the original step
-      yield
-
-      # take screenshot AFTER the action is completed
-      base_dir = if CapyDash.respond_to?(:configuration)
-        CapyDash.configuration&.screenshot_path || "tmp/capydash_screenshots"
-      else
-        "tmp/capydash_screenshots"
-      end
-      FileUtils.mkdir_p(base_dir) unless Dir.exist?(base_dir)
-      timestamp = Time.now.strftime('%Y%m%d-%H%M%S-%L')
-      safe_step = step_name.gsub(/\s+/, '_')
-      screenshot_path = File.join(base_dir, "#{safe_step}-#{timestamp}.png")
-
-      # Ensure we have an absolute path for Base64 encoding
-      absolute_screenshot_path = File.absolute_path(screenshot_path)
-
-      data_url = nil
-      if defined?(Capybara)
-        begin
-          current_driver = Capybara.current_driver
-          if current_driver != :rack_test
-            if respond_to?(:page)
-              page.save_screenshot(screenshot_path)
-            else
-              Capybara.current_session.save_screenshot(screenshot_path)
-            end
-
-            # Try to find the actual screenshot file location
-            actual_screenshot_path = nil
-            if File.exist?(absolute_screenshot_path)
-              actual_screenshot_path = absolute_screenshot_path
-            else
-              # Check if it was saved in the capybara tmp directory
-              capybara_path = File.join(Dir.pwd, "tmp", "capybara", screenshot_path)
-              if File.exist?(capybara_path)
-                actual_screenshot_path = capybara_path
-              end
-            end
-
-            if actual_screenshot_path && File.exist?(actual_screenshot_path)
-              encoded = Base64.strict_encode64(File.binread(actual_screenshot_path))
-              data_url = "data:image/png;base64,#{encoded}"
-            end
-          end
-        rescue => e
-          # Silently handle screenshot capture failures
-        end
-      end
-
-      # mark success with screenshot
-      CapyDash::EventEmitter.broadcast(
-        step_name: step_name,
-        detail: detail,
-        screenshot: actual_screenshot_path || screenshot_path,
-        data_url: data_url,
-        test_name: (defined?(CapyDash) ? CapyDash.current_test : nil),
-        status: "passed"
-      )
-    rescue => e
-      # take screenshot even on failure (after the action was attempted)
-      base_dir = if CapyDash.respond_to?(:configuration)
-        CapyDash.configuration&.screenshot_path || "tmp/capydash_screenshots"
-      else
-        "tmp/capydash_screenshots"
-      end
-      FileUtils.mkdir_p(base_dir) unless Dir.exist?(base_dir)
-      timestamp = Time.now.strftime('%Y%m%d-%H%M%S-%L')
-      safe_step = step_name.gsub(/\s+/, '_')
-      screenshot_path = File.join(base_dir, "#{safe_step}-#{timestamp}.png")
-
-      # Ensure we have an absolute path for Base64 encoding
-      absolute_screenshot_path = File.absolute_path(screenshot_path)
-
-      data_url = nil
-      if defined?(Capybara)
-        begin
-          current_driver = Capybara.current_driver
-          if current_driver != :rack_test
-            if respond_to?(:page)
-              page.save_screenshot(screenshot_path)
-            else
-              Capybara.current_session.save_screenshot(screenshot_path)
-            end
-
-            # Try to find the actual screenshot file location
-            actual_screenshot_path = nil
-            if File.exist?(absolute_screenshot_path)
-              actual_screenshot_path = absolute_screenshot_path
-            else
-              # Check if it was saved in the capybara tmp directory
-              capybara_path = File.join(Dir.pwd, "tmp", "capybara", screenshot_path)
-              if File.exist?(capybara_path)
-                actual_screenshot_path = capybara_path
-              end
-            end
-
-            if actual_screenshot_path && File.exist?(actual_screenshot_path)
-              encoded = Base64.strict_encode64(File.binread(actual_screenshot_path))
-              data_url = "data:image/png;base64,#{encoded}"
-            end
-          end
-        rescue => e
-          # Silently handle screenshot capture failures
-        end
-      end
-
-      CapyDash::EventEmitter.broadcast(
-        step_name: step_name,
-        detail: detail,
-        screenshot: actual_screenshot_path || screenshot_path,
-        data_url: data_url,
-        test_name: (defined?(CapyDash) ? CapyDash.current_test : nil),
-        status: "failed",
-        error: e.message
-      )
-      raise e
-    end
-  end
-end
-
-# Prepend into Capybara DSL so it wraps all calls
-Capybara::Session.prepend(CapyDash::Instrumentation)

data/lib/capydash/logger.rb

@@ -1,99 +0,0 @@
-require 'logger'
-require 'fileutils'
-
-module CapyDash
-  class Logger
-    class << self
-      attr_accessor :instance
-    end
-
-    def initialize(config = nil)
-      @config = config || Configuration.new
-      @logger = create_logger
-    end
-
-    def self.setup(config = nil)
-      self.instance = new(config)
-    end
-
-    def self.info(message, context = {})
-      instance&.info(message, context)
-    end
-
-    def self.warn(message, context = {})
-      instance&.warn(message, context)
-    end
-
-    def self.error(message, context = {})
-      instance&.error(message, context)
-    end
-
-    def self.debug(message, context = {})
-      instance&.debug(message, context)
-    end
-
-    def info(message, context = {})
-      log(:info, message, context)
-    end
-
-    def warn(message, context = {})
-      log(:warn, message, context)
-    end
-
-    def error(message, context = {})
-      log(:error, message, context)
-    end
-
-    def debug(message, context = {})
-      log(:debug, message, context)
-    end
-
-    private
-
-    def create_logger
-      # Ensure log directory exists
-      log_dir = File.dirname(@config.log_file)
-      FileUtils.mkdir_p(log_dir) unless Dir.exist?(log_dir)
-
-      # Create logger with file rotation
-      logger = ::Logger.new(
-        @config.log_file,
-        @config.max_files,
-        @config.max_file_size
-      )
-
-      # Set log level
-      logger.level = case @config.log_level.downcase
-                    when 'debug' then ::Logger::DEBUG
-                    when 'info' then ::Logger::INFO
-                    when 'warn' then ::Logger::WARN
-                    when 'error' then ::Logger::ERROR
-                    else ::Logger::INFO
-                    end
-
-      # Set format
-      logger.formatter = proc do |severity, datetime, progname, msg|
-        "#{datetime.strftime('%Y-%m-%d %H:%M:%S')} [#{severity}] #{progname}: #{msg}\n"
-      end
-
-      logger
-    end
-
-    def log(level, message, context = {})
-      return unless @logger
-
-      # Add context information
-      full_message = message
-      if context.any?
-        context_str = context.map { |k, v| "#{k}=#{v}" }.join(' ')
-        full_message = "#{message} | #{context_str}"
-      end
-
-      @logger.send(level, full_message)
-    rescue => e
-      # Fallback to stdout if logging fails
-      puts "Logging error: #{e.message}"
-      puts "#{level.upcase}: #{message}"
-    end
-  end
-end

data/lib/capydash/persistence.rb

@@ -1,134 +0,0 @@
-require 'json'
-require 'fileutils'
-
-module CapyDash
-  class Persistence
-    class << self
-      def save_test_run(test_run_data)
-        ensure_data_directory
-        file_path = test_run_file_path(test_run_data[:id] || generate_run_id)
-
-        begin
-          File.write(file_path, JSON.pretty_generate(test_run_data))
-          file_path
-        rescue => e
-          ErrorHandler.handle_error(e, {
-            error_type: 'persistence',
-            operation: 'save_test_run',
-            run_id: test_run_data[:id]
-          })
-          nil
-        end
-      end
-
-      def load_test_run(run_id)
-        file_path = test_run_file_path(run_id)
-        return nil unless File.exist?(file_path)
-
-        begin
-          JSON.parse(File.read(file_path), symbolize_names: true)
-        rescue => e
-          ErrorHandler.handle_error(e, {
-            error_type: 'persistence',
-            operation: 'load_test_run',
-            run_id: run_id
-          })
-          nil
-        end
-      end
-
-      def list_test_runs(limit = 50)
-        ensure_data_directory
-        data_dir = data_directory
-
-        begin
-          Dir.glob(File.join(data_dir, "test_run_*.json"))
-            .sort_by { |f| File.mtime(f) }
-            .reverse
-            .first(limit)
-            .map do |file_path|
-              run_id = File.basename(file_path, '.json').gsub('test_run_', '')
-              {
-                id: run_id,
-                file_path: file_path,
-                created_at: File.mtime(file_path),
-                size: File.size(file_path)
-              }
-            end
-        rescue => e
-          ErrorHandler.handle_error(e, {
-            error_type: 'persistence',
-            operation: 'list_test_runs'
-          })
-          []
-        end
-      end
-
-      def delete_test_run(run_id)
-        file_path = test_run_file_path(run_id)
-        return false unless File.exist?(file_path)
-
-        begin
-          File.delete(file_path)
-          Logger.info("Test run deleted", { run_id: run_id })
-          true
-        rescue => e
-          ErrorHandler.handle_error(e, {
-            error_type: 'persistence',
-            operation: 'delete_test_run',
-            run_id: run_id
-          })
-          false
-        end
-      end
-
-      def cleanup_old_runs(days_to_keep = 30)
-        ensure_data_directory
-        cutoff_time = Time.now - (days_to_keep * 24 * 60 * 60)
-        deleted_count = 0
-
-        begin
-          Dir.glob(File.join(data_directory, "test_run_*.json")).each do |file_path|
-            if File.mtime(file_path) < cutoff_time
-              run_id = File.basename(file_path, '.json').gsub('test_run_', '')
-              if delete_test_run(run_id)
-                deleted_count += 1
-              end
-            end
-          end
-
-          Logger.info("Cleanup completed", {
-            deleted_runs: deleted_count,
-            days_kept: days_to_keep
-          })
-
-          deleted_count
-        rescue => e
-          ErrorHandler.handle_error(e, {
-            error_type: 'persistence',
-            operation: 'cleanup_old_runs'
-          })
-          0
-        end
-      end
-
-      private
-
-      def data_directory
-        @data_directory ||= File.join(Dir.pwd, "tmp", "capydash_data")
-      end
-
-      def ensure_data_directory
-        FileUtils.mkdir_p(data_directory) unless Dir.exist?(data_directory)
-      end
-
-      def test_run_file_path(run_id)
-        File.join(data_directory, "test_run_#{run_id}.json")
-      end
-
-      def generate_run_id
-        "#{Time.now.to_i}_#{SecureRandom.hex(4)}"
-      end
-    end
-  end
-end