event_system 0.1.0

data/spec/integration/readme_examples_spec.rb

@@ -0,0 +1,447 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'README Examples Integration Tests' do
+  describe 'Basic Usage Example' do
+    it 'demonstrates basic event creation and publishing' do
+      # Create an event manager
+      manager = EventSystem.create_manager
+
+      # Create and publish an event
+      event = manager.publish_event(:user_created, self, { user_id: 123, name: "John Doe" })
+      
+      expect(event).to be_a(EventSystem::Event)
+      expect(event.type).to eq('user_created')
+      expect(event.data[:user_id]).to eq(123)
+      expect(event.data[:name]).to eq('John Doe')
+    end
+
+    it 'demonstrates event subscription' do
+      manager = EventSystem.create_manager
+
+      # Subscribe to events
+      class UserNotifier
+        include EventSystem::EventSubscriber
+        
+        attr_reader :events_received
+        
+        def initialize
+          @events_received = []
+        end
+        
+        def handle_event(event)
+          @events_received << event
+        end
+      end
+
+      notifier = UserNotifier.new
+      manager.subscribe(:user_created, notifier)
+      
+      # Publish event
+      manager.publish_event(:user_created, self, { user_id: 123, name: "John Doe" })
+      
+      expect(notifier.events_received.length).to eq(1)
+      expect(notifier.events_received.first.type).to eq('user_created')
+    end
+  end
+
+  describe 'Configuration Example' do
+    it 'demonstrates file storage configuration' do
+      # Configure with file storage
+      config = {
+        storage_type: :file,
+        storage_options: { directory: @temp_dir },
+        session_id: "my_app_session"
+      }
+
+      manager = EventSystem.create_manager(config)
+      
+      expect(manager.config.storage_type).to eq(:file)
+      expect(manager.config.storage_options[:directory]).to eq(@temp_dir)
+      expect(manager.config.session_id).to eq("my_app_session")
+    end
+
+    it 'demonstrates memory storage for testing' do
+      manager = EventSystem.create_manager(storage_type: :memory)
+      expect(manager.config.storage_type).to eq(:memory)
+    end
+  end
+
+  describe 'Event Creation Example' do
+    it 'demonstrates manual event creation' do
+      manager = EventSystem.create_manager
+
+      # Create an event manually
+      event = EventSystem.create_event(:order_placed, self, {
+        order_id: 456,
+        customer_id: 789,
+        amount: 99.99
+      })
+
+      expect(event.type).to eq('order_placed')
+      expect(event.data[:order_id]).to eq(456)
+      expect(event.data[:customer_id]).to eq(789)
+      expect(event.data[:amount]).to eq(99.99)
+
+      # Publish the event
+      manager.publish(event)
+    end
+  end
+
+  describe 'Event Subscribers Example' do
+    it 'demonstrates order processing with multiple event types' do
+      manager = EventSystem.create_manager
+
+      class OrderProcessor
+        include EventSystem::EventSubscriber
+        
+        attr_reader :processed_orders, :fulfilled_orders
+        
+        def initialize
+          @processed_orders = []
+          @fulfilled_orders = []
+        end
+        
+        def handle_event(event)
+          case event.type
+          when 'order_placed'
+            process_order(event.data)
+          when 'payment_received'
+            fulfill_order(event.data)
+          end
+        end
+        
+        private
+        
+        def process_order(data)
+          @processed_orders << data
+        end
+        
+        def fulfill_order(data)
+          @fulfilled_orders << data
+        end
+      end
+
+      processor = OrderProcessor.new
+      manager.subscribe(:order_placed, processor)
+      manager.subscribe(:payment_received, processor)
+
+      # Publish events
+      manager.publish_event(:order_placed, 'OrderService', { order_id: 123, amount: 50.0 })
+      manager.publish_event(:payment_received, 'PaymentService', { order_id: 123, amount: 50.0 })
+
+      expect(processor.processed_orders.length).to eq(1)
+      expect(processor.fulfilled_orders.length).to eq(1)
+      expect(processor.processed_orders.first[:order_id]).to eq(123)
+    end
+
+    it 'demonstrates subscribe_all functionality' do
+      manager = EventSystem.create_manager
+
+      class UniversalSubscriber
+        include EventSystem::EventSubscriber
+        
+        attr_reader :all_events
+        
+        def initialize
+          @all_events = []
+        end
+        
+        def handle_event(event)
+          @all_events << event
+        end
+      end
+
+      subscriber = UniversalSubscriber.new
+      manager.subscribe_all(subscriber)
+
+      # Publish different event types
+      manager.publish_event(:event1, 'Source1', { data: 'value1' })
+      manager.publish_event(:event2, 'Source2', { data: 'value2' })
+
+      expect(subscriber.all_events.length).to eq(2)
+      expect(subscriber.all_events.map(&:type)).to include('event1', 'event2')
+    end
+  end
+
+  describe 'Event Querying Example' do
+    it 'demonstrates various querying capabilities' do
+      manager = create_file_manager
+
+      # Publish various events
+      manager.publish_event(:order_placed, 'OrderService', { order_id: 1, amount: 100 })
+      manager.publish_event(:order_placed, 'OrderService', { order_id: 2, amount: 200 })
+      manager.publish_event(:user_created, 'UserService', { user_id: 1, name: 'John' })
+      
+      # Query events by type
+      orders = manager.query_events(type: 'order_placed')
+      expect(orders.length).to eq(2)
+      expect(orders.all? { |e| e.type == 'order_placed' }).to be true
+
+      # Query events by time range
+      start_time = Time.now - 3600 # 1 hour in seconds
+      end_time = Time.now + 3600   # 1 hour in seconds
+      recent_events = manager.query_events(start_time: start_time, end_time: end_time)
+      expect(recent_events.length).to eq(3)
+
+      # Query with limit
+      last_2_events = manager.query_events(limit: 2)
+      expect(last_2_events.length).to eq(2)
+
+      # Query from specific session
+      session_events = manager.query_events(session_id: manager.current_session)
+      expect(session_events.length).to eq(3)
+    end
+  end
+
+  describe 'Storage Backends Example' do
+    it 'demonstrates memory storage for testing' do
+      manager = EventSystem.create_manager(storage_type: :memory)
+
+      # Switch sessions
+      manager.switch_session('test_session_1')
+      manager.publish_event(:test_event, self, { data: 'test' })
+
+      # Create new session
+      new_session = manager.create_session('my_new_session')
+      expect(new_session).to eq('my_new_session')
+      expect(manager.current_session).to eq('my_new_session')
+    end
+
+    it 'demonstrates file storage persistence' do
+      config = {
+        storage_type: :file,
+        storage_options: { directory: @temp_dir }
+      }
+      manager = EventSystem.create_manager(config)
+
+      # Events are automatically saved to JSONL files
+      manager.publish_event(:user_action, self, { action: 'login' })
+      
+      # Verify file was created
+      session_file = File.join(@temp_dir, "events_#{manager.current_session}.jsonl")
+      expect(File.exist?(session_file)).to be true
+      
+      # Verify content
+      content = File.read(session_file)
+      expect(content).to include('user_action')
+      expect(content).to include('login')
+    end
+  end
+
+  describe 'Visualization Example' do
+    it 'demonstrates timeline generation' do
+      manager = create_file_manager
+
+      # Add some events
+      manager.publish_event(:user_created, 'UserService', { user_id: 123, name: 'John Doe' })
+      manager.publish_event(:order_placed, 'OrderService', { order_id: 456, amount: 99.99 })
+
+      # Generate timeline visualization
+      generator = EventSystem::Visualization::TimelineGenerator.new(manager.storage)
+      html_file = generator.generate_timeline(nil, 'timeline.html')
+      
+      expect(html_file).to be_a(String)
+      expect(File.exist?(html_file)).to be true
+      expect(html_file).to end_with('.html')
+    end
+
+    it 'demonstrates event summary' do
+      manager = create_file_manager
+
+      # Add events
+      manager.publish_event(:user_created, 'UserService', { user_id: 1 })
+      manager.publish_event(:user_created, 'UserService', { user_id: 2 })
+      manager.publish_event(:order_placed, 'OrderService', { order_id: 1 })
+
+      generator = EventSystem::Visualization::TimelineGenerator.new(manager.storage)
+      summary = generator.event_summary
+      
+      expect(summary).to be_a(Hash)
+      expect(summary['user_created']).to eq(2)
+      expect(summary['order_placed']).to eq(1)
+    end
+
+    it 'demonstrates timeline data export' do
+      manager = create_file_manager
+
+      manager.publish_event(:test_event, 'TestSource', { key: 'value' })
+
+      generator = EventSystem::Visualization::TimelineGenerator.new(manager.storage)
+      timeline_data = generator.timeline_data
+      
+      expect(timeline_data).to be_an(Array)
+      expect(timeline_data.length).to eq(1)
+      
+      event_data = timeline_data.first
+      expect(event_data[:type]).to eq('test_event')
+      expect(event_data[:source]).to eq('TestSource')
+      expect(event_data[:data][:key]).to eq('value')
+    end
+  end
+
+  describe 'Advanced Configuration Example' do
+    it 'demonstrates custom configuration' do
+      # Custom configuration
+      config = EventSystem::Configuration.new
+      config.storage_type = :file
+      config.storage_options = { directory: @temp_dir }
+      config.session_id = 'production_session'
+      config.auto_flush = true
+
+      manager = EventSystem.create_manager(config)
+      
+      expect(manager.config.storage_type).to eq(:file)
+      expect(manager.config.storage_options[:directory]).to eq(@temp_dir)
+      expect(manager.config.session_id).to eq('production_session')
+      expect(manager.config.auto_flush).to be true
+    end
+
+    it 'demonstrates custom logger configuration' do
+      require 'logger'
+      log_io = StringIO.new
+      config = EventSystem::Configuration.new
+      config.logger = Logger.new(log_io)
+
+      manager = EventSystem.create_manager(config)
+      
+      # Publish an event to trigger logging
+      manager.publish_event(:test_event, self, { data: 'test' })
+      
+      # Check that logging occurred
+      log_content = log_io.string
+      expect(log_content).to include('EventSystem initialized')
+      expect(log_content).to include('Publishing event')
+    end
+  end
+
+  describe 'Error Handling Example' do
+    it 'demonstrates safe subscriber error handling' do
+      manager = EventSystem.create_manager
+
+      class SafeSubscriber
+        include EventSystem::EventSubscriber
+        
+        attr_reader :errors_handled
+        
+        def initialize
+          @errors_handled = []
+        end
+        
+        def handle_event(event)
+          if event.data[:should_fail]
+            raise StandardError, 'Test error'
+          end
+        end
+      end
+
+      safe_subscriber = SafeSubscriber.new
+      manager.subscribe(:test_event, safe_subscriber)
+
+      # Publish event that should not fail
+      manager.publish_event(:test_event, self, { should_fail: false })
+      
+      # Publish event that should fail (but be handled gracefully)
+      expect { 
+        manager.publish_event(:test_event, self, { should_fail: true })
+      }.not_to raise_error
+    end
+  end
+
+  describe 'Web Application Example' do
+    it 'demonstrates web application event handling' do
+      class WebApp
+        attr_reader :event_manager, :events_logged
+        
+        def initialize
+          @event_manager = EventSystem.create_manager(
+            storage_type: :file,
+            storage_options: { directory: @temp_dir }
+          )
+          @events_logged = []
+          
+          # Subscribe to web events
+          @event_manager.subscribe(:request_received, self)
+          @event_manager.subscribe(:response_sent, self)
+        end
+        
+        def handle_request(request)
+          @event_manager.publish_event(:request_received, self, {
+            path: request[:path],
+            method: request[:method],
+            ip: request[:ip]
+          })
+        end
+        
+        def handle_event(event)
+          @events_logged << event
+        end
+      end
+
+      web_app = WebApp.new
+      
+      # Simulate request
+      request = { path: '/api/users', method: 'GET', ip: '127.0.0.1' }
+      web_app.handle_request(request)
+      
+      expect(web_app.events_logged.length).to eq(1)
+      event = web_app.events_logged.first
+      expect(event.type).to eq('request_received')
+      expect(event.data[:path]).to eq('/api/users')
+      expect(event.data[:method]).to eq('GET')
+    end
+  end
+
+  describe 'Microservice Communication Example' do
+    it 'demonstrates microservice event communication' do
+      class OrderService
+        attr_reader :event_manager, :orders_fulfilled
+        
+        def initialize
+          @event_manager = EventSystem.create_manager
+          @orders_fulfilled = []
+          @event_manager.subscribe(:payment_processed, self)
+        end
+        
+        def place_order(order_data)
+          @event_manager.publish_event(:order_created, self, order_data)
+        end
+        
+        def handle_event(event)
+          if event.type == 'payment_processed'
+            fulfill_order(event.data[:order_id])
+          end
+        end
+        
+        private
+        
+        def fulfill_order(order_id)
+          @orders_fulfilled << order_id
+        end
+      end
+
+      order_service = OrderService.new
+      
+      # Place an order
+      order_service.place_order({ customer_id: 123, amount: 100 })
+      
+      # Simulate payment processing
+      order_service.event_manager.publish_event(:payment_processed, 'PaymentService', { order_id: 1 })
+      
+      expect(order_service.orders_fulfilled).to include(1)
+    end
+  end
+
+  describe 'Testing Example' do
+    it 'demonstrates testing with memory storage' do
+      event_manager = EventSystem.create_manager(storage_type: :memory)
+      
+      # Mock the publish_event method to verify it's called
+      expect(event_manager).to receive(:publish_event).with(:order_created, anything, anything)
+      
+      # Simulate service behavior
+      event_manager.publish_event(:order_created, 'TestService', { customer_id: 123 })
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'event_system'
+require 'rspec'
+require 'tempfile'
+require 'fileutils'
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = '.rspec_status'
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  # Clean up temporary files after each test
+  config.after(:each) do
+    # Clean up any temporary files created during tests
+    if defined?(@temp_dir) && @temp_dir && Dir.exist?(@temp_dir)
+      FileUtils.rm_rf(@temp_dir)
+    end
+  end
+
+  # Helper method to create a temporary directory for file storage tests
+  config.before(:each) do
+    @temp_dir = Dir.mktmpdir('event_system_test')
+  end
+end
+
+# Helper methods for testing
+module EventSystemTestHelpers
+  def create_test_event(type = :test_event, source = 'TestSource', data = {})
+    EventSystem::Event.new(type, source, data)
+  end
+
+  def create_test_manager(storage_type = :memory, options = {})
+    config = {
+      storage_type: storage_type,
+      storage_options: options
+    }
+    EventSystem.create_manager(config)
+  end
+
+  def create_file_manager(temp_dir = nil)
+    temp_dir ||= @temp_dir
+    create_test_manager(:file, { directory: temp_dir })
+  end
+
+  def create_test_subscriber(name = 'TestSubscriber')
+    Class.new do
+      include EventSystem::EventSubscriber
+      attr_reader :name, :events_received
+
+      def initialize(name)
+        @name = name
+        @events_received = []
+      end
+
+      def handle_event(event)
+        @events_received << event
+      end
+
+      def handles_event_type?(event_type)
+        true
+      end
+
+      def event_priority
+        0
+      end
+    end.new(name)
+  end
+end
+
+RSpec.configure do |config|
+  config.include EventSystemTestHelpers
+end

metadata

@@ -0,0 +1,171 @@
+--- !ruby/object:Gem::Specification
+name: event_system
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- David Silva
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Event-driven architecture with pluggable storage backends, visualization
+  tools, and comprehensive logging. Perfect for building decoupled, maintainable applications.
+email:
+- davidslv@users.noreply.github.com
+executables:
+- event_system
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- README.md
+- Rakefile
+- docs/event_visualizations/example_timeline.html
+- docs/example_logs/events_20251027_151744.jsonl
+- docs/example_logs/events_20251027_151802.jsonl
+- docs/examples/basic_usage.rb
+- exe/event_system
+- lib/event_system.rb
+- lib/event_system/configuration.rb
+- lib/event_system/event.rb
+- lib/event_system/event_manager.rb
+- lib/event_system/event_subscriber.rb
+- lib/event_system/storage/base.rb
+- lib/event_system/storage/file_store.rb
+- lib/event_system/storage/memory_store.rb
+- lib/event_system/version.rb
+- lib/event_system/visualization/timeline_generator.rb
+- spec/event_system/configuration_spec.rb
+- spec/event_system/event_manager_spec.rb
+- spec/event_system/event_spec.rb
+- spec/event_system/event_subscriber_spec.rb
+- spec/event_system/storage/file_store_spec.rb
+- spec/event_system/storage/memory_store_spec.rb
+- spec/event_system/visualization/timeline_generator_spec.rb
+- spec/event_system_spec.rb
+- spec/integration/readme_examples_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/davidslv/event_system
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/davidslv/event_system
+  source_code_uri: https://github.com/davidslv/event_system
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A flexible, agnostic event system for Ruby applications
+test_files: []