capydash 0.2.0 → 0.2.1

data/lib/capydash/auth.rb

@@ -1,103 +0,0 @@
-require 'securerandom'
-require 'digest'
-
-module CapyDash
-  class Auth
-    class << self
-      def authenticate(username, password)
-        return false unless auth_enabled?
-
-        # Simple hardcoded credentials for MVP
-        # In production, this would connect to a proper user database
-        valid_credentials = {
-          'admin' => 'capydash123',
-          'developer' => 'test123',
-          'viewer' => 'readonly123'
-        }
-
-        if valid_credentials[username] == password
-          token = generate_token(username)
-          Logger.info("User authenticated", {
-            username: username,
-            token: token[0..8] + "..."
-          })
-          token
-        else
-          Logger.warn("Authentication failed", {
-            username: username,
-            ip: current_ip
-          })
-          nil
-        end
-      end
-
-      def validate_token(token)
-        return false unless auth_enabled?
-        return false unless token && token.length > 10
-
-        # Simple token validation for MVP
-        # In production, this would use JWT or similar
-        begin
-          decoded = Base64.decode64(token)
-          parts = decoded.split(':')
-          return false unless parts.length == 3
-
-          username, timestamp, signature = parts
-          expected_signature = generate_signature(username, timestamp)
-
-          if signature == expected_signature
-            # Check if token is not expired (24 hours)
-            token_time = Time.at(timestamp.to_i)
-            if Time.now - token_time < 24 * 60 * 60
-              Logger.debug("Token validated", { username: username })
-              username
-            else
-              Logger.warn("Token expired", { username: username })
-              false
-            end
-          else
-            Logger.warn("Invalid token signature", { token: token[0..8] + "..." })
-            false
-          end
-        rescue => e
-          ErrorHandler.handle_error(e, {
-            error_type: 'authentication',
-            operation: 'validate_token'
-          })
-          false
-        end
-      end
-
-      def auth_enabled?
-        CapyDash.config.auth_enabled?
-      end
-
-      def require_auth!
-        return true unless auth_enabled?
-        # This would be called by middleware or controllers
-        # For now, just return true
-        true
-      end
-
-      private
-
-      def generate_token(username)
-        timestamp = Time.now.to_i.to_s
-        signature = generate_signature(username, timestamp)
-        token_data = "#{username}:#{timestamp}:#{signature}"
-        Base64.encode64(token_data).strip
-      end
-
-      def generate_signature(username, timestamp)
-        secret = CapyDash.config.secret_key
-        data = "#{username}:#{timestamp}:#{secret}"
-        Digest::SHA256.hexdigest(data)
-      end
-
-      def current_ip
-        # In a real app, this would get the actual IP
-        "127.0.0.1"
-      end
-    end
-  end
-end

data/lib/capydash/configuration.rb

@@ -1,186 +0,0 @@
-module CapyDash
-  class Configuration
-    attr_accessor :server, :dashboard, :tests, :logging, :security, :performance
-
-    def initialize
-      @server = {
-        host: "localhost",
-        port: 4000,
-        websocket_path: "/websocket",
-        max_connections: 100,
-        message_history_limit: 1000
-      }
-
-      @dashboard = {
-        title: "CapyDash Test Monitor",
-        refresh_interval: 1000,
-        auto_scroll: true,
-        show_timestamps: true,
-        screenshot_quality: 0.8,
-        max_screenshot_width: 1200
-      }
-
-      @tests = {
-        default_directory: "test",
-        system_tests_dir: "test/system",
-        feature_tests_dir: "test/features",
-        controller_tests_dir: "test/controllers",
-        model_tests_dir: "test/models",
-        screenshot_dir: "tmp/capydash_screenshots",
-        timeout: 300
-      }
-
-      @logging = {
-        level: "info",
-        file: "log/capydash.log",
-        max_file_size: "10MB",
-        max_files: 5
-      }
-
-      @security = {
-        enable_auth: false,
-        secret_key: "your-secret-key-here",
-        session_timeout: 3600
-      }
-
-      @performance = {
-        enable_compression: true,
-        cleanup_interval: 300,
-        max_memory_usage: "512MB"
-      }
-    end
-
-    def self.load_from_file(config_path = nil)
-      config_path ||= File.join(Dir.pwd, "config", "capydash.yml")
-
-      if File.exist?(config_path)
-        require 'yaml'
-        yaml_config = YAML.load_file(config_path)
-
-        config = new
-        config.load_from_hash(yaml_config)
-        config
-      else
-        # Return default configuration if file doesn't exist
-        new
-      end
-    rescue => e
-      puts "Warning: Could not load configuration from #{config_path}: #{e.message}"
-      puts "Using default configuration."
-      new
-    end
-
-    def load_from_hash(hash)
-      @server.merge!(hash['server']) if hash['server']
-      @dashboard.merge!(hash['dashboard']) if hash['dashboard']
-      @tests.merge!(hash['tests']) if hash['tests']
-      @logging.merge!(hash['logging']) if hash['logging']
-      @security.merge!(hash['security']) if hash['security']
-      @performance.merge!(hash['performance']) if hash['performance']
-    end
-
-    def server_host
-      @server[:host]
-    end
-
-    def server_port
-      @server[:port]
-    end
-
-    def websocket_path
-      @server[:websocket_path]
-    end
-
-    def max_connections
-      @server[:max_connections]
-    end
-
-    def message_history_limit
-      @server[:message_history_limit]
-    end
-
-    def dashboard_title
-      @dashboard[:title]
-    end
-
-    def auto_scroll?
-      @dashboard[:auto_scroll]
-    end
-
-    def show_timestamps?
-      @dashboard[:show_timestamps]
-    end
-
-    def screenshot_quality
-      @dashboard[:screenshot_quality]
-    end
-
-    def max_screenshot_width
-      @dashboard[:max_screenshot_width]
-    end
-
-    def system_tests_dir
-      @tests[:system_tests_dir]
-    end
-
-    def feature_tests_dir
-      @tests[:feature_tests_dir]
-    end
-
-    def controller_tests_dir
-      @tests[:controller_tests_dir]
-    end
-
-    def model_tests_dir
-      @tests[:model_tests_dir]
-    end
-
-    def screenshot_dir
-      @tests[:screenshot_dir]
-    end
-
-    def test_timeout
-      @tests[:timeout]
-    end
-
-    def log_level
-      @logging[:level]
-    end
-
-    def log_file
-      @logging[:file]
-    end
-
-    def max_files
-      @logging[:max_files]
-    end
-
-    def max_file_size
-      @logging[:max_file_size]
-    end
-
-    def auth_enabled?
-      @security[:enable_auth]
-    end
-
-    def secret_key
-      @security[:secret_key]
-    end
-
-    def session_timeout
-      @security[:session_timeout]
-    end
-
-    def compression_enabled?
-      @performance[:enable_compression]
-    end
-
-    def cleanup_interval
-      @performance[:cleanup_interval]
-    end
-
-    def max_memory_usage
-      @performance[:max_memory_usage]
-    end
-  end
-end

data/lib/capydash/dashboard_server.rb

@@ -1,167 +0,0 @@
-require 'eventmachine'
-require 'em-websocket'
-
-module CapyDash
-  class DashboardServer
-    attr_reader :port, :clients
-
-    # Provide a single shared instance for the whole process
-    def self.instance(port: nil)
-      configured_port = port || CapyDash.config.server_port
-      @instance ||= new(port: configured_port)
-    end
-
-    def initialize(port: nil)
-      @port = port || CapyDash.config.server_port
-      @clients = []
-      @history = [] # recent events to replay on reconnect
-      @history_limit = CapyDash.config.message_history_limit
-      @max_connections = CapyDash.config.max_connections
-    end
-
-    # Start the WebSocket server in a background thread
-    def start
-      return if defined?(@started) && @started
-      @started = true
-      Thread.new do
-        EM.run do
-          EM::WebSocket.run(host: "0.0.0.0", port: @port) do |ws|
-
-            ws.onopen do
-              begin
-                # Check connection limit
-                if @clients.length >= @max_connections
-                  CapyDash::Logger.warn("Connection limit reached", {
-                    current_connections: @clients.length,
-                    max_connections: @max_connections
-                  })
-                  ws.close
-                  return
-                end
-
-                @clients << ws
-                CapyDash::Logger.info("Client connected", {
-                  total_clients: @clients.length,
-                  client_id: ws.object_id
-                })
-                puts "Client connected"
-
-                # Replay recent history so refreshed clients see last events
-                @history.each do |msg|
-                  begin
-                    ws.send(msg)
-                  rescue => e
-                    CapyDash::ErrorHandler.handle_websocket_error(e, ws)
-                  end
-                end
-              rescue => e
-                CapyDash::ErrorHandler.handle_websocket_error(e, ws)
-              end
-            end
-
-            ws.onclose do
-              begin
-                @clients.delete(ws)
-                CapyDash::Logger.info("Client disconnected", {
-                  remaining_clients: @clients.length,
-                  client_id: ws.object_id
-                })
-                puts "Client disconnected"
-              rescue => e
-                CapyDash::ErrorHandler.handle_websocket_error(e, ws)
-              end
-            end
-
-            ws.onmessage do |msg|
-              begin
-                CapyDash::Logger.debug("Received WebSocket message", {
-                  message_length: msg.length,
-                  client_id: ws.object_id
-                })
-                puts "Received message: #{msg}"
-
-                data = JSON.parse(msg) rescue nil
-                if data && data["command"] == "run_tests"
-                  args = data["args"] || ["bundle", "exec", "rails", "test", "test/system"]
-                  CapyDash::Logger.info("Executing test command", {
-                    command: args.join(' '),
-                    client_id: ws.object_id
-                  })
-
-                  Thread.new do
-                    begin
-                      # Change to the dummy app directory and run tests there
-                      current_dir = File.dirname(__FILE__)
-                      gem_root = File.expand_path(File.join(current_dir, "..", ".."))
-                      dummy_app_path = File.join(gem_root, "spec", "dummy_app")
-
-                      CapyDash::Logger.info("Running tests in directory", {
-                        directory: dummy_app_path,
-                        exists: Dir.exist?(dummy_app_path)
-                      })
-
-                      Dir.chdir(dummy_app_path) do
-                        # Set Rails environment and ensure CapyDash is loaded
-                        ENV["RAILS_ENV"] = "test"
-                        ENV["CAPYDASH_EXTERNAL_WS"] = "1"  # Use external WebSocket mode
-
-
-                        # Run the command and capture both stdout and stderr
-                        IO.popen(args, err: [:child, :out]) do |io|
-                          io.each_line do |line|
-                            event = { type: "runner", line: line.strip, status: "running", ts: Time.now.to_i }
-                            broadcast(event.to_json)
-                          end
-                        end
-                      end
-                    rescue => e
-                      CapyDash::ErrorHandler.handle_test_execution_error(e, args.join(' '))
-                      broadcast({ type: "runner", line: "Error: #{e.message}", status: "failed", ts: Time.now.to_i }.to_json)
-                    end
-                    broadcast({ type: "runner", line: "Finished", status: "passed", ts: Time.now.to_i }.to_json)
-                  end
-                else
-                  # Optionally broadcast to all clients
-                  broadcast(msg)
-                end
-              rescue => e
-                CapyDash::ErrorHandler.handle_websocket_error(e, ws)
-              end
-            end
-
-          end
-        end
-      end
-    end
-
-    # Send a message to all connected clients
-    def broadcast(message)
-      begin
-        # store in history buffer
-        @history << message
-        @history.shift if @history.length > @history_limit
-
-        # fan out to all connected clients
-        @clients.each do |client|
-          begin
-            client.send(message)
-          rescue => e
-            CapyDash::ErrorHandler.handle_websocket_error(e, client)
-            # Remove dead connections
-            @clients.delete(client)
-          end
-        end
-      rescue => e
-        CapyDash::ErrorHandler.handle_error(e, {
-          error_type: 'broadcast',
-          message_length: message&.length
-        })
-      end
-    end
-
-    # Stop the WebSocket server gracefully
-    def stop
-      EM.stop_event_loop if EM.reactor_running?
-    end
-  end
-end

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