lowevent 0.8.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 58811c1dffb8954d8dd1ef1e40e322ffb2b6ea6a9d824e1205c05d1803e6c565
+  data.tar.gz: 12afa112f58ad6f0aa1425572db2f8d38a32416d9f48d58be3bf172a0e7d2b40
+SHA512:
+  metadata.gz: da3ccf1f9f03e42f3172237b1c70196485d512146ad4e0d5a4d7e1aa27d6357fbcc381285115d79c241052f8dec7bbe3d52d97d786f00d821e5e5811aaa4b4de
+  data.tar.gz: 6d03f85b9cc65fe1cecbb0a9254d5a31a636a8e85b557f37fe20814f70b4c4095c7c182037692cf3c3b16c15cdbecbfc5b2b06c3196bc2f6437084e9782dad9b

data/lib/events/hidden_event.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'lowtype'
+
+module Low
+  module Events
+    # An event that happens on event tree branching and isn't added to the event tree/sequence.
+    class HiddenEvent
+      include LowType
+
+      attr_reader :key, :action, :created_at
+
+      def initialize(key:, action: nil)
+        @key = key
+        @action = action
+        @created_at = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+      end
+
+      def trigger
+        event_tree = branch
+        key = Observers::Keys[@key]
+        key.trigger(event: self) { restore_level(event_tree:) }
+      end
+
+      class << self
+        def trigger(**kwargs)
+          new(**kwargs).trigger
+        end
+
+        def inherited(child)
+          child.include LowType
+        end
+      end
+    end
+  end
+end

data/lib/events/render_event.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Low
+  module Events
+    RenderEvent = Data.define(:action, :props) do
+      # TODO: Duplicate props when used in a parallelized situation (antlers: "<{ :parallelize }>")
+      def initialize(action: :render, props: {})
+        super
+      end
+    end
+  end
+end

data/lib/events/request_event.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/event'
+
+module Low
+  module Events
+    class RequestEvent < Event
+      attr_reader :request
+
+      def initialize(request:, action: :request)
+        super(key: self.class, action:)
+
+        @request = request
+      end
+    end
+  end
+end

data/lib/events/response_event.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'protocol/http'
+require_relative '../interfaces/event'
+
+module Low
+  module Events
+    class ResponseEvent < Event
+      attr_reader :response
+
+      # TODO: Type: "response: Protocol::HTTP::Response"
+      def initialize(response: nil)
+        super(key: self.class, action: :respond)
+
+        @response = response
+      end
+    end
+  end
+end

data/lib/events/status_event.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative '../interfaces/event'
+
+module Low
+  module Events
+    class StatusEvent < Event
+      attr_reader :status, :request
+
+      def initialize(status:, request:, key: nil, action: :render)
+        super(key: key || status, action:)
+
+        @status = status
+        @request = request
+      end
+
+      # Status is a complex type that can be represented by both "Status" generically and "Status[:code]" specifically.
+      class << self
+        def trigger(status:, **kwargs)
+          new(status:, **kwargs).trigger || new(status:, key: Status, **kwargs).trigger
+        end
+      end
+    end
+  end
+end

data/lib/factories/response_factory.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'protocol/http'
+
+module Low
+  module Events
+    class ResponseFactory
+      class << self
+        def response(body:)
+          headers = Protocol::HTTP::Headers.new(['content-type', 'text/html'])
+          body = Protocol::HTTP::Body::Buffered.wrap(body.strip)
+
+          Protocol::HTTP::Response.new('http/1.1', 200, headers, body)
+        end
+      end
+    end
+  end
+end

data/lib/interfaces/definable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Low
+  module Events
+    module Definable
+      def define(key = self)
+        yield observers(key)
+      end
+
+      class << self
+        def included(klass)
+          klass.extend Definable
+        end
+      end
+    end
+  end
+end

data/lib/interfaces/event.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'lowtype'
+require 'observers'
+require_relative 'definable'
+require_relative '../support/value_object'
+
+module Low
+  # An event represents what is currently happening; the past, present and future.
+  #
+  # They are action-driven, representing inputs and outputs in a linear pipeline-like flow,
+  # which end up as children of the event... which is why events are mutable (except for RenderEvent).
+  # They are one-to-many with a return value.
+  #
+  # Integrations:
+  # - Observers for observer pattern which we wrap in an event-centric API
+  # - EventPool for a tree of events and their child events (defined in this gem)
+  # - LowState for state machines to trigger multiple ordered actions [UNLRELEASED]
+  class Event
+    include LowType
+    include Observers
+    include Events::Definable
+    include Support::ValueObject
+
+    attr_reader :key, :action, :actions, :created_at
+    attr_accessor :children
+
+    # Subclass provides a key such as "self.class".
+    # Subclass defines default action or actions, but not both.
+    def initialize(key:, action: nil, actions: [], children: [])
+      @key = key
+      @action = action
+      @actions = actions
+      @children = children
+
+      @created_at = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
+    end
+
+    def trigger
+      event_tree = branch
+      key = Observers::Keys[@key]
+      key.trigger(event: self) { restore_level(event_tree:) }
+    end
+
+    def take
+      event_tree = branch
+      key = Observers::Keys[@key]
+      key.take(event: self) { restore_level(event_tree:) }
+    end
+
+    def branch
+      event_tree = Providers['low.event.pool'].current_event_tree(event: self)
+      event_tree.branch(event: self)
+    end
+    
+    private
+
+    def restore_level(event_tree:)
+      event_tree.current_event = self if event_tree.respond_to?(:current_event)
+    end
+
+    class << self
+      def trigger(**kwargs) = new(**kwargs).trigger
+      def take(**kwargs) = new(**kwargs).take
+
+      def inherited(child)
+        child.include LowType
+        increase_count
+        add_event(child)
+      end
+
+      def count
+        @count ||= 0
+      end
+
+      def increase_count
+        @count = count + 1
+      end
+
+      def events
+        @events ||= []
+      end
+
+      def add_event(event)
+        events << event
+      end
+    end
+  end
+end

data/lib/lowevent.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'providers'
+
+require_relative 'events/render_event'
+require_relative 'events/request_event'
+require_relative 'events/response_event'
+require_relative 'events/status_event'
+require_relative 'factories/response_factory' # TODO: Find out who's using this and require it there.
+require_relative 'interfaces/event'
+require_relative 'pool/event_pool'
+
+Providers.define('low.event.pool') do
+  Low::Events::EventPool.new
+end
+
+LowEvent = Low::Event

data/lib/pool/branch_event.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative '../events/hidden_event'
+
+module Low
+  module Events
+    class BranchEvent < HiddenEvent
+      attr_reader :event_tree, :event
+
+      def initialize(event_tree:, event:)
+        super(key: BranchEvent, action: :branch)
+
+        @event_tree = event_tree
+        @event = event
+      end
+    end
+  end
+end

data/lib/pool/event_pool.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'observers'
+
+require_relative '../events/request_event'
+require_relative 'event_tree'
+require_relative '../support/pool_hash'
+
+module Low
+  module Events
+    class EventPool
+      include Observers
+
+      BUFFER_SIZE = 100
+
+      def initialize
+        @event_trees = Support::PoolHash.new(BUFFER_SIZE)
+        @request_counts = Support::PoolHash.new(BUFFER_SIZE)
+      end
+
+      def current_event_tree(event:)
+        request_id = request_id(event:)
+
+        return @event_trees[request_id] if @event_trees[request_id]
+
+        event_tree = @event_trees.add(request_id, EventTree.new(request_id:))
+        trigger action: :new_event_tree, event: event_tree
+
+        event_tree
+      end
+
+      def event_trees
+        @event_trees
+      end
+
+      private
+
+      def request_id(event:)
+        fiber_id = Fiber.current.object_id
+        increment_request_counts(fiber_id:) if event.is_a?(RequestEvent)
+        "#{fiber_id}-#{@request_counts[fiber_id]}"
+      end
+
+      def increment_request_counts(fiber_id:)
+        @request_counts[fiber_id] ||= 0
+        @request_counts[fiber_id] += 1
+      end
+    end
+  end
+end

data/lib/pool/event_tree.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'observers'
+require_relative 'branch_event'
+
+module Low
+  module Events
+    class EventTree
+      include Observers
+
+      attr_reader :request_id, :root_event, :sequence
+      attr_accessor :current_event
+
+      def initialize(request_id: nil)
+        @request_id = request_id
+        @root_event = nil
+        @current_event = nil
+        @sequence = []
+      end
+
+      def branch(event:)
+        @sequence << event
+
+        if @root_event.nil?
+          @root_event = event
+          @current_event = event
+        else
+          @current_event.children << event
+        end
+
+        trigger action: :branch, event: BranchEvent.new(event_tree: self, event:)
+      end
+    end
+  end
+end

data/lib/support/pool_hash.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Low
+  module Support
+    class PoolHash < Hash
+      def initialize(max_size)
+        @max_size = max_size
+
+        super()
+      end
+
+      def add(key, value)
+        # Prune the hash when a new item added.
+        if size >= @max_size && !key?(key)
+          # TODO: Notify event pool that item was removed.
+          _old_key, _old_value = shift
+        end
+
+        self[key] = value
+      end
+    end
+  end
+end

data/lib/support/value_object.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Low
+  module Support
+    module ValueObject
+      def ==(other) = other.class == self.class
+      def eql?(other) = self == other
+      def hash = [self.class].hash
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Low
+  EVENT_VERSION = '0.8.1'
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: lowevent
+version: !ruby/object:Gem::Version
+  version: 0.8.1
+platform: ruby
+authors:
+- maedi
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lowtype
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: observers
+  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: protocol-http
+  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: providers
+  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'
+description: Events and observers for event-driven applications
+email:
+- maediprichard@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/events/hidden_event.rb
+- lib/events/render_event.rb
+- lib/events/request_event.rb
+- lib/events/response_event.rb
+- lib/events/status_event.rb
+- lib/factories/response_factory.rb
+- lib/interfaces/definable.rb
+- lib/interfaces/event.rb
+- lib/lowevent.rb
+- lib/pool/branch_event.rb
+- lib/pool/event_pool.rb
+- lib/pool/event_tree.rb
+- lib/support/pool_hash.rb
+- lib/support/value_object.rb
+- lib/version.rb
+homepage: https://github.com/low-rb/lowevent
+licenses: []
+metadata:
+  homepage_uri: https://github.com/low-rb/lowevent
+  source_code_uri: https://github.com/low-rb/lowevent/src/branch/main
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Observable events
+test_files: []