capydash 0.2.0 → 0.2.1

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