capydash 0.2.0 → 0.2.2

data/lib/capydash.rb

@@ -1,64 +1,15 @@
-require 'ostruct'
 require "capydash/version"
-require "capydash/engine"
-require "capydash/instrumentation"
-require "capydash/event_emitter"
-require "capydash/dashboard_server"
-require "capydash/configuration"
-require "capydash/logger"
-require "capydash/error_handler"
-require "capydash/persistence"
-require "capydash/auth"
-require "capydash/test_data_collector"
-require "capydash/test_data_aggregator"
-require "capydash/report_generator"
 
-# Conditionally load RSpec integration if RSpec is present
-if defined?(RSpec)
-  require "capydash/rspec_integration"
-  CapyDash::RSpecIntegration.setup!
-end
-
-module CapyDash
-  class << self
-    attr_accessor :configuration, :current_test, :config
-
-    def configure
-      self.configuration ||= OpenStruct.new
-      yield(configuration)
-    end
-
-    def config
-      @config ||= Configuration.load_from_file
-    end
-
-    def config=(new_config)
-      @config = new_config
-    end
-
-    # Convenience methods for common operations
-    def log_info(message, context = {})
-      Logger.info(message, context)
-    end
-
-    def log_error(message, context = {})
-      Logger.error(message, context)
-    end
-
-    def handle_error(error, context = {})
-      ErrorHandler.handle_error(error, context)
-    end
-
-    def save_test_run(data)
-      Persistence.save_test_run(data)
-    end
-
-    def load_test_run(run_id)
-      Persistence.load_test_run(run_id)
-    end
-
-    def list_test_runs(limit = 50)
-      Persistence.list_test_runs(limit)
+# Auto-setup RSpec integration if RSpec is present and ready
+if defined?(RSpec) && RSpec.respond_to?(:configure)
+  require "capydash/rspec"
+  CapyDash::RSpec.setup!
+elsif defined?(Rails)
+  # In Rails, RSpec might load after the gem, so set up a hook
+  Rails.application.config.after_initialize do
+    if defined?(RSpec) && RSpec.respond_to?(:configure)
+      require "capydash/rspec" unless defined?(CapyDash::RSpec)
+      CapyDash::RSpec.setup!
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: capydash
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Damon Clark
@@ -10,21 +10,7 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: railties
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '5.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '5.0'
-- !ruby/object:Gem::Dependency
-  name: capybara
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -38,77 +24,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: faye-websocket
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: eventmachine
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: em-websocket
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec
+  name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '6.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '6.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '8.0'
-description: CapyDash instruments Capybara tests and streams test steps, screenshots,
-  and DOM snapshots to a live dashboard.
+        version: '6.0'
+description: CapyDash automatically generates clean, readable HTML test reports after
+  your RSpec suite finishes. Zero configuration required.
 email:
 - dclark312@gmail.com
 executables: []
@@ -118,24 +62,9 @@ files:
 - README.md
 - capydash.gemspec
 - lib/capydash.rb
-- lib/capydash/auth.rb
-- lib/capydash/configuration.rb
-- lib/capydash/dashboard_server.rb
-- lib/capydash/engine.rb
-- lib/capydash/error_handler.rb
-- lib/capydash/event_emitter.rb
-- lib/capydash/forwarder.rb
-- lib/capydash/instrumentation.rb
-- lib/capydash/logger.rb
-- lib/capydash/persistence.rb
-- lib/capydash/report_generator.rb
-- lib/capydash/rspec_integration.rb
+- lib/capydash/rspec.rb
 - lib/capydash/templates/report.html.erb
-- lib/capydash/test_data_aggregator.rb
-- lib/capydash/test_data_collector.rb
 - lib/capydash/version.rb
-- lib/generators/capydash/install_generator.rb
-- lib/tasks/capydash.rake
 homepage: https://github.com/damonclark/capydash
 licenses:
 - MIT
@@ -157,5 +86,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.7
 specification_version: 4
-summary: Real-time Capybara test dashboard
+summary: Minimal static HTML report generator for RSpec system tests
 test_files: []

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