RubyGems - event_system - Versions diffs - 0.1.0 - Mend

event_system 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (30) hide show

checksums.yaml +7 -0
data/.rspec +3 -0
data/README.md +362 -0
data/Rakefile +4 -0
data/docs/event_visualizations/example_timeline.html +142 -0
data/docs/example_logs/events_20251027_151744.jsonl +3 -0
data/docs/example_logs/events_20251027_151802.jsonl +3 -0
data/docs/examples/basic_usage.rb +64 -0
data/exe/event_system +139 -0
data/lib/event_system/configuration.rb +125 -0
data/lib/event_system/event.rb +139 -0
data/lib/event_system/event_manager.rb +191 -0
data/lib/event_system/event_subscriber.rb +29 -0
data/lib/event_system/storage/base.rb +64 -0
data/lib/event_system/storage/file_store.rb +187 -0
data/lib/event_system/storage/memory_store.rb +134 -0
data/lib/event_system/version.rb +5 -0
data/lib/event_system/visualization/timeline_generator.rb +237 -0
data/lib/event_system.rb +37 -0
data/spec/event_system/configuration_spec.rb +197 -0
data/spec/event_system/event_manager_spec.rb +341 -0
data/spec/event_system/event_spec.rb +193 -0
data/spec/event_system/event_subscriber_spec.rb +295 -0
data/spec/event_system/storage/file_store_spec.rb +341 -0
data/spec/event_system/storage/memory_store_spec.rb +248 -0
data/spec/event_system/visualization/timeline_generator_spec.rb +252 -0
data/spec/event_system_spec.rb +57 -0
data/spec/integration/readme_examples_spec.rb +447 -0
data/spec/spec_helper.rb +80 -0
metadata +171 -0

data/spec/event_system/visualization/timeline_generator_spec.rb ADDED Viewed

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+require 'spec_helper'
+RSpec.describe EventSystem::Visualization::TimelineGenerator do
+  let(:temp_dir) { @temp_dir }
+  let(:storage) { EventSystem::Storage::FileStore.new(temp_dir, 'test_session') }
+  let(:generator) { EventSystem::Visualization::TimelineGenerator.new(storage) }
+  before do
+    # Add some test events
+    storage.store(create_test_event(:user_created, 'UserService', { user_id: 123, name: 'John Doe' }))
+    storage.store(create_test_event(:order_placed, 'OrderService', { order_id: 456, amount: 99.99 }))
+    storage.store(create_test_event(:payment_received, 'PaymentService', { payment_id: 789, amount: 99.99 }))
+  end
+  describe '#initialize' do
+    it 'initializes with storage' do
+      expect(generator.storage).to eq(storage)
+    end
+  end
+  describe '#generate_timeline' do
+    it 'generates HTML timeline for current session' do
+      output_path = generator.generate_timeline
+      expect(output_path).to be_a(String)
+      expect(File.exist?(output_path)).to be true
+      expect(output_path).to end_with('.html')
+    end
+    it 'generates HTML timeline for specific session' do
+      output_path = generator.generate_timeline('test_session')
+      expect(output_path).to be_a(String)
+      expect(File.exist?(output_path)).to be true
+    end
+    it 'generates HTML timeline with custom output file' do
+      output_path = generator.generate_timeline('test_session', 'custom_timeline.html')
+      expect(output_path).to include('custom_timeline.html')
+      expect(File.exist?(output_path)).to be true
+    end
+    it 'returns nil when no events found' do
+      # Create a storage with no session files
+      empty_storage = EventSystem::Storage::FileStore.new(temp_dir)
+      # Mock list_sessions to return empty array
+      allow(empty_storage).to receive(:list_sessions).and_return([])
+      empty_generator = EventSystem::Visualization::TimelineGenerator.new(empty_storage)
+      result = empty_generator.generate_timeline
+      expect(result).to be_nil
+    end
+    it 'creates event_visualizations directory' do
+      generator.generate_timeline
+      expect(Dir.exist?('event_visualizations')).to be true
+    end
+    it 'generates valid HTML content' do
+      output_path = generator.generate_timeline
+      content = File.read(output_path)
+      expect(content).to include('<!DOCTYPE html>')
+      expect(content).to include('<html lang="en">')
+      expect(content).to include('Event Timeline')
+      expect(content).to include('test_session')
+    end
+    it 'includes event statistics' do
+      output_path = generator.generate_timeline
+      content = File.read(output_path)
+      expect(content).to include('Total Events')
+      expect(content).to include('Event Types')
+      expect(content).to include('Sources')
+    end
+    it 'includes filter controls' do
+      output_path = generator.generate_timeline
+      content = File.read(output_path)
+      expect(content).to include('Filter by type:')
+      expect(content).to include('Search events...')
+    end
+    it 'includes JavaScript for filtering' do
+      output_path = generator.generate_timeline
+      content = File.read(output_path)
+      expect(content).to include('function filterEvents()')
+      expect(content).to include('addEventListener')
+    end
+  end
+  describe '#latest_session_id' do
+    it 'returns the most recent session ID' do
+      # Create files with different names (alphabetically sorted)
+      older_file = File.join(@temp_dir, 'events_a_session.jsonl')
+      newer_file = File.join(@temp_dir, 'events_z_session.jsonl')
+      # Create older file
+      File.write(older_file, '{"type":"test","source":"test","timestamp":"2023-01-01T00:00:00.000Z","id":"old-id","data":{}}')
+      # Create newer file
+      File.write(newer_file, '{"type":"test","source":"test","timestamp":"2023-01-02T00:00:00.000Z","id":"new-id","data":{}}')
+      # Create generator with the directory
+      generator = EventSystem::Visualization::TimelineGenerator.new(EventSystem::Storage::FileStore.new(@temp_dir))
+      latest = generator.latest_session_id
+      expect(latest).to eq('z_session')
+    end
+    it 'returns nil when no sessions exist' do
+      empty_storage = EventSystem::Storage::FileStore.new(temp_dir)
+      allow(empty_storage).to receive(:list_sessions).and_return([])
+      empty_generator = EventSystem::Visualization::TimelineGenerator.new(empty_storage)
+      result = empty_generator.latest_session_id
+      expect(result).to be_nil
+    end
+  end
+  describe '#event_summary' do
+    it 'returns summary of events by type' do
+      summary = generator.event_summary('test_session')
+      expect(summary).to be_a(Hash)
+      expect(summary['user_created']).to eq(1)
+      expect(summary['order_placed']).to eq(1)
+      expect(summary['payment_received']).to eq(1)
+    end
+    it 'returns summary for latest session by default' do
+      summary = generator.event_summary
+      expect(summary).to be_a(Hash)
+      expect(summary.keys).to include('user_created', 'order_placed', 'payment_received')
+    end
+    it 'returns empty hash for non-existent session' do
+      summary = generator.event_summary('non_existent')
+      expect(summary).to eq({})
+    end
+  end
+  describe '#timeline_data' do
+    it 'returns timeline data structure' do
+      data = generator.timeline_data('test_session')
+      expect(data).to be_an(Array)
+      expect(data.length).to eq(3)
+      event_data = data.first
+      expect(event_data).to have_key(:id)
+      expect(event_data).to have_key(:type)
+      expect(event_data).to have_key(:timestamp)
+      expect(event_data).to have_key(:source)
+      expect(event_data).to have_key(:data)
+      expect(event_data).to have_key(:duration)
+    end
+    it 'includes proper event data' do
+      data = generator.timeline_data('test_session')
+      event_data = data.find { |e| e[:type] == 'user_created' }
+      expect(event_data[:source]).to eq('UserService')
+      expect(event_data[:data][:user_id]).to eq(123)
+      expect(event_data[:data][:name]).to eq('John Doe')
+    end
+    it 'returns data for latest session by default' do
+      data = generator.timeline_data
+      expect(data).to be_an(Array)
+      expect(data.length).to eq(3)
+    end
+    it 'returns empty array for non-existent session' do
+      data = generator.timeline_data('non_existent')
+      expect(data).to eq([])
+    end
+  end
+  describe 'HTML generation' do
+    let(:output_path) { generator.generate_timeline }
+    it 'includes all event types in filter dropdown' do
+      content = File.read(output_path)
+      expect(content).to include('<option value="user_created">user_created</option>')
+      expect(content).to include('<option value="order_placed">order_placed</option>')
+      expect(content).to include('<option value="payment_received">payment_received</option>')
+    end
+    it 'includes event data in timeline' do
+      content = File.read(output_path)
+      expect(content).to include('user_id')
+      expect(content).to include('John Doe')
+      expect(content).to include('order_id')
+      expect(content).to include('99.99')
+    end
+    it 'includes proper CSS styling' do
+      content = File.read(output_path)
+      expect(content).to include('body { font-family: Arial, sans-serif;')
+      expect(content).to include('.timeline-item')
+      expect(content).to include('.event-header')
+    end
+    it 'includes JavaScript functionality' do
+      content = File.read(output_path)
+      expect(content).to include('const events =')
+      expect(content).to include('filterEvents()')
+      expect(content).to include('generateEventHTML')
+    end
+  end
+  describe 'error handling' do
+    it 'handles storage errors gracefully' do
+      # Mock storage to raise an error
+      allow(storage).to receive(:load_session).and_raise(StandardError, 'Storage error')
+      expect { generator.generate_timeline }.to raise_error(StandardError, 'Storage error')
+    end
+    it 'handles file writing errors gracefully' do
+      # Mock File.write to raise an error
+      allow(File).to receive(:write).and_raise(StandardError, 'File write error')
+      expect { generator.generate_timeline }.to raise_error(StandardError, 'File write error')
+    end
+  end
+  describe 'integration with different storage types' do
+    it 'works with memory storage' do
+      memory_storage = EventSystem::Storage::MemoryStore.new('memory_session')
+      memory_storage.store(create_test_event(:test_event, 'TestSource', { key: 'value' }))
+      memory_generator = EventSystem::Visualization::TimelineGenerator.new(memory_storage)
+      output_path = memory_generator.generate_timeline
+      expect(output_path).to be_a(String)
+      expect(File.exist?(output_path)).to be true
+    end
+  end
+end

data/spec/event_system_spec.rb ADDED Viewed

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+require 'spec_helper'
+RSpec.describe EventSystem do
+  describe '.version' do
+    it 'returns the current version' do
+      expect(EventSystem.version).to eq('0.1.0')
+    end
+  end
+  describe '.create_manager' do
+    it 'creates a manager with default configuration' do
+      manager = EventSystem.create_manager
+      expect(manager).to be_a(EventSystem::EventManager)
+      expect(manager.config.storage_type).to eq(:memory)
+    end
+    it 'creates a manager with custom configuration hash' do
+      config = { storage_type: :file, storage_options: { directory: 'test_logs' } }
+      manager = EventSystem.create_manager(config)
+      expect(manager.config.storage_type).to eq(:file)
+      expect(manager.config.storage_options[:directory]).to eq('test_logs')
+    end
+    it 'creates a manager with Configuration object' do
+      config = EventSystem::Configuration.new
+      config.storage_type = :file
+      manager = EventSystem.create_manager(config)
+      expect(manager.config).to eq(config)
+    end
+  end
+  describe '.create_event' do
+    it 'creates an event with type only' do
+      event = EventSystem.create_event(:test_type)
+      expect(event).to be_a(EventSystem::Event)
+      expect(event.type).to eq('test_type')
+      expect(event.source).to be_nil
+      expect(event.data).to eq({})
+    end
+    it 'creates an event with type and source' do
+      event = EventSystem.create_event(:test_type, 'TestSource')
+      expect(event.type).to eq('test_type')
+      expect(event.source).to eq('TestSource')
+    end
+    it 'creates an event with all parameters' do
+      data = { key: 'value' }
+      event = EventSystem.create_event(:test_type, 'TestSource', data)
+      expect(event.type).to eq('test_type')
+      expect(event.source).to eq('TestSource')
+      expect(event.data).to eq(data)
+    end
+  end
+end