test_bench-bootstrap 3.0.0.0.pre.1 → 3.0.0

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry/event.rb

@@ -1,130 +0,0 @@
-module TestBenchBootstrap
-  module TestBench
-    class Telemetry
-      module Event
-        def self.define(*attributes, &blk)
-          Struct.new(*attributes, :metadata) do
-            include Event
-
-            if not blk.nil?
-              instance_exec(&blk)
-            end
-          end
-        end
-
-        def self.included(cls)
-          cls.class_exec do
-            extend EventType
-            extend EventName
-
-            extend Build
-
-            extend CaseEquality
-          end
-        end
-
-        def event_type
-          self.class.event_type
-        end
-
-        def event_name
-          self.class.event_name
-        end
-
-        def data
-          values[0...-1]
-        end
-
-        module EventType
-          def event_type
-            @event_type ||= event_type!
-          end
-
-          def event_type!
-            *, inner_namespace = self.name.split('::')
-
-            inner_namespace.to_sym
-          end
-        end
-
-        module EventName
-          def event_name
-            EventName.get(event_type)
-          end
-
-          def self.get(event_type)
-            pascal_cased = event_type.to_s
-
-            underscore_cased = pascal_cased.gsub(%r{(?:\A|[a-z])[A-Z]+}) do |match_text|
-              if ('a'..'z').include?(match_text[0])
-                match_text.insert(1, '_')
-              end
-              match_text.downcase!
-              match_text
-            end
-
-            underscore_cased.to_sym
-          end
-        end
-
-        module Export
-          def self.call(event)
-            event_data = EventData.new
-            event_data.type = event.event_type
-            event_data.data = event.data
-            event_data.process_id = event.metadata.process_id
-            event_data.time = event.metadata.time
-            event_data
-          end
-        end
-
-        module Build
-          def build(*attributes, process_id: nil, time: nil)
-            time ||= ::Time.now
-            process_id ||= ::Process.pid
-
-            metadata = Metadata.new(process_id, time)
-
-            instance = new(*attributes)
-            instance.metadata = metadata
-            instance
-          end
-        end
-
-        module CaseEquality
-          def ===(object)
-            case object
-            in EventData => event_data
-              type = event_data.type
-
-              type == self.event_type
-
-            else
-              super(object)
-            end
-          end
-        end
-
-        module Import
-          Error = Class.new(RuntimeError)
-
-          def self.call(event_data, event_class)
-            if event_class.event_type != event_data.type
-              raise Error, "Event class #{event_class} doesn't match EventData type #{event_data.type.inspect}"
-            end
-
-            process_id = event_data.process_id
-            time = event_data.time
-            data = event_data.data
-
-            metadata = Metadata.new(process_id, time)
-
-            event_class.new(*data, metadata)
-          end
-        end
-
-        Metadata = Struct.new(:process_id, :time)
-      end
-    end
-  end
-end

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry/event_data/serialization.rb

@@ -1,85 +0,0 @@
-module TestBenchBootstrap
-  module TestBench
-    class Telemetry
-      class EventData
-        module Serialization
-          def self.dump(event_data)
-            data = event_data.data.map do |value|
-              case value
-              in Time => time
-                timestamp(time)
-              else
-                value
-              end
-            end
-
-            type = event_data.type
-            process_id = event_data.process_id
-
-            time = event_data.time
-            if not time.nil?
-              timestamp = timestamp(time)
-            end
-
-            json_text = JSON.generate([type, process_id, timestamp, data])
-            json_text << "\n"
-            json_text
-          end
-
-          def self.load(text)
-            type, process_id, timestamp, data = JSON.parse(text)
-
-            type = type.to_sym
-
-            if not timestamp.nil?
-              time = time(timestamp)
-            end
-
-            event_data = EventData.new
-            event_data.type = type
-            event_data.process_id = process_id
-            event_data.time = time
-            event_data.data = data
-
-            event_data
-          end
-
-          def self.timestamp(time)
-            time.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
-          end
-
-          def self.time(timestamp)
-            match_data = time_pattern.match(timestamp)
-
-            year = match_data['year'].to_i
-            month = match_data['month'].to_i
-            day = match_data['day'].to_i
-            hour = match_data['hour'].to_i
-            minute = match_data['minute'].to_i
-            second = match_data['second'].to_i
-
-            nanosecond = match_data['nanosecond'].to_i
-            usec = Rational(nanosecond, 1_000)
-
-            Time.utc(year, month, day, hour, minute, second, usec)
-          end
-
-          def self.time_pattern
-            @time_pattern ||=
-              begin
-                year = %r{(?<year>[[:digit:]]{4})}
-                month = %r{(?<month>[[:digit:]]{2})}
-                day = %r{(?<day>[[:digit:]]{2})}
-                hour = %r{(?<hour>[[:digit:]]{2})}
-                minute = %r{(?<minute>[[:digit:]]{2})}
-                second = %r{(?<second>[[:digit:]]{2})}
-                nanosecond = %r{(?<nanosecond>[[:digit:]]{9})}
-
-                %r{\A#{year}-#{month}-#{day}T#{hour}:#{minute}:#{second}\.#{nanosecond}Z\z}
-              end
-          end
-        end
-      end
-    end
-  end
-end

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry/event_data.rb

@@ -1,15 +0,0 @@
-module TestBenchBootstrap
-  module TestBench
-    class Telemetry
-      EventData = Struct.new(:type, :process_id, :time, :data) do
-        def self.load(text)
-          EventData::Serialization.load(text)
-        end
-
-        def dump
-          EventData::Serialization.dump(self)
-        end
-      end
-    end
-  end
-end

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry/sink/file.rb

@@ -1,39 +0,0 @@
-module TestBenchBootstrap
-  module TestBench
-    class Telemetry
-      module Sink
-        class File
-          include Sink
-
-          attr_reader :file
-
-          def initialize(file)
-            @file = file
-          end
-
-          def self.build(file_path)
-            file = ::File.open(file_path, 'w')
-
-            new(file)
-          end
-
-          def self.open(file_path, &block)
-            ::File.open(file_path, 'w') do |file|
-              instance = new(file)
-
-              block.(instance, file)
-
-              return instance
-            end
-          end
-
-          def receive(event_data)
-            text = event_data.dump
-
-            file.write(text)
-          end
-        end
-      end
-    end
-  end
-end

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry/sink/handler/event_registry.rb

@@ -1,44 +0,0 @@
-module TestBenchBootstrap
-  module TestBench
-    class Telemetry
-      module Sink
-        module Handler
-          class EventRegistry
-            Error = Class.new(RuntimeError)
-
-            def event_classes
-              @event_classes ||= {}
-            end
-            attr_writer :event_classes
-
-            def event_types
-              event_classes.keys
-            end
-
-            def get(event_type)
-              event_classes.fetch(event_type) do
-                raise Error, "#{event_type} isn't registered"
-              end
-            end
-
-            def register(event_class)
-              if registered?(event_class)
-                raise Error, "#{event_class} is already registered"
-              end
-
-              event_type = event_class.event_type
-
-              event_classes[event_type] = event_class
-            end
-
-            def registered?(event_class)
-              event_type = event_class.event_type
-
-              event_classes.key?(event_type)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry/sink/handler.rb

@@ -1,128 +0,0 @@
-module TestBenchBootstrap
-  module TestBench
-    class Telemetry
-      module Sink
-        module Handler
-          def self.included(cls)
-            cls.class_exec do
-              include Sink
-              include Receive
-
-              extend HandlerMethod
-              extend HandleMacro
-            end
-          end
-
-          module Receive
-            def receive(event_data)
-              handle(event_data)
-            end
-          end
-
-          def handle(event_or_event_data)
-            handles = handle?(event_or_event_data)
-
-            if handles
-              if event_or_event_data.is_a?(Event)
-                event = event_or_event_data
-              else
-                event_data = event_or_event_data
-                event_type = event_data.type
-                event_class = self.class.event_registry.get(event_type)
-
-                event = Event::Import.(event_data, event_class)
-              end
-
-              handler_method = handler_method(event)
-
-              if method(handler_method).parameters.any?
-                __send__(handler_method, event)
-              else
-                __send__(handler_method)
-              end
-
-              event
-            elsif respond_to?(:handle_event_data)
-              if event_or_event_data.is_a?(Event)
-                event_data = Event::Export.(event_or_event_data)
-              else
-                event_data = event_or_event_data
-              end
-
-              handle_event_data(event_data)
-
-              event_data
-            else
-              nil
-            end
-          end
-
-          def handle?(...)
-            handler_method = handler_method(...)
-
-            not handler_method.nil?
-          end
-
-          def handler_method(event_or_event_data)
-            handler_method = self.class.handler_method(event_or_event_data)
-
-            if respond_to?(handler_method)
-              handler_method
-            else
-              nil
-            end
-          end
-
-          module HandleMacro
-            def handle_macro(event_class, &block)
-              event_registry.register(event_class)
-
-              event_type = event_class.event_type
-
-              handler_method = HandlerMethod.get(event_type)
-
-              define_method(handler_method, &block)
-            end
-            alias :handle :handle_macro
-
-            def event_registry
-              @event_registry ||= EventRegistry.new
-            end
-          end
-
-          module HandlerMethod
-            def handler_method(event_or_event_data)
-              if event_or_event_data.is_a?(Event)
-                event = event_or_event_data
-                event_type = event.event_type
-              else
-                event_data = event_or_event_data
-                event_type = event_data.type
-              end
-
-              HandlerMethod.get(event_type)
-            end
-
-            def self.get(event_type)
-              handler_methods[event_type]
-            end
-
-            def self.handler_methods
-              @handler_methods ||= Hash.new do |handler_methods, event_type|
-                handler_method = get!(event_type)
-
-                handler_methods[event_type] = handler_method
-              end
-            end
-
-            def self.get!(event_type)
-              event_name = Event::EventName.get(event_type)
-
-              :"handle_#{event_name}"
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry/sink.rb

@@ -1,13 +0,0 @@
-module TestBenchBootstrap
-  module TestBench
-    class Telemetry
-      module Sink
-        ReceiveError = Class.new(RuntimeError)
-
-        def receive(event_data)
-          raise ReceiveError, "Sink #{self.class} doesn't implement receive"
-        end
-      end
-    end
-  end
-end

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry/substitute/sink.rb

@@ -1,71 +0,0 @@
-module TestBenchBootstrap
-  module TestBench
-    class Telemetry
-      module Substitute
-        class Sink
-          MatchError = Class.new(RuntimeError)
-
-          include Telemetry::Sink
-
-          def received_events
-            @received_events ||= []
-          end
-
-          def receive(event_data)
-            received_events << event_data
-          end
-
-          def received?(event_data)
-            received_events.include?(event_data)
-          end
-
-          def one_event?(...)
-            !one_event(...).nil?
-          end
-
-          def one_event(...)
-            events = events(...)
-
-            if events.count > 1
-              event_type = events.first.event_type
-              raise MatchError, "More than one event matches (Type: #{event_type.inspect}, Matching Events: #{events.count})"
-            end
-
-            events.first
-          end
-
-          def any_event?(...)
-            events(...).any?
-          end
-          alias :event? :any_event?
-
-          def events(event_class, **attributes)
-            event_type = event_class.event_type
-
-            events = []
-
-            received_events.each do |event_data|
-              event_types_correspond = event_data.type == event_type
-
-              if event_types_correspond
-                event = Event::Import.(event_data, event_class)
-
-                attributes_correspond = attributes.all? do |attribute, compare_value|
-                  value = event.public_send(attribute)
-
-                  value == compare_value
-                end
-
-                if attributes_correspond
-                  events << event
-                end
-              end
-            end
-
-            events
-          end
-        end
-      end
-    end
-  end
-end

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry/substitute.rb

@@ -1,43 +0,0 @@
-module TestBenchBootstrap
-  module TestBench
-    class Telemetry
-      module Substitute
-        def self.build
-          Telemetry.build
-        end
-
-        class Telemetry < Telemetry
-          attr_accessor :process_id
-          attr_accessor :current_time
-
-          def sink
-            @sink ||= Substitute::Sink.new
-          end
-          attr_writer :sink
-
-          def self.build
-            instance = new
-            instance.register(instance.sink)
-            instance
-          end
-
-          def one_event?(...) = sink.one_event?(...)
-          def one_event(...) = sink.one_event(...)
-          def any_event?(...) = sink.any_event?(...)
-          alias :event? :any_event?
-          def events(...) = sink.events(...)
-
-          def recorded?(event_or_event_data)
-            case event_or_event_data
-            in Event => event
-              event_data = Event::Export.(event)
-            in EventData => event_data
-            end
-
-            sink.received?(event_data)
-          end
-        end
-      end
-    end
-  end
-end

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry/telemetry.rb

@@ -1,92 +0,0 @@
-module TestBenchBootstrap
-  module TestBench
-    class Telemetry
-      RegistrationError = Class.new(RuntimeError)
-      GetError = Class.new(RuntimeError)
-
-      def sinks
-        @sinks ||= []
-      end
-      attr_writer :sinks
-
-      def self.build(*sinks)
-        instance = new
-
-        sinks.each do |sink|
-          instance.register(sink)
-        end
-
-        instance
-      end
-
-      def self.configure(receiver, *sinks, attr_name: nil)
-        attr_name ||= :telemetry
-
-        instance = build(*sinks)
-        receiver.public_send(:"#{attr_name}=", instance)
-      end
-
-      def record(event)
-        if event.is_a?(Event)
-          event.metadata ||= Event::Metadata.new
-
-          event_data = Event::Export.(event)
-        else
-          event_data = event
-        end
-
-        sinks.each do |sink|
-          sink.receive(event_data)
-        end
-
-        event_data
-      end
-
-      def register(sink)
-        if registered?(sink)
-          raise RegistrationError, "Already registered #{sink.inspect}"
-        end
-
-        sinks.push(sink)
-      end
-
-      def unregister(sink)
-        deleted_sink = sinks.delete(sink)
-
-        if deleted_sink.nil?
-          raise RegistrationError, "Not registered #{sink.inspect}"
-        end
-      end
-
-      def registered?(sink_or_sink_class)
-        if sink_or_sink_class.is_a?(Sink)
-          sink = sink_or_sink_class
-
-          sinks.include?(sink)
-        else
-          sink_class = sink_or_sink_class
-
-          sink = get_sink(sink_class)
-
-          !sink.nil?
-        end
-      end
-
-      def get_sink(sink_class)
-        sink, *other_sinks = get_sinks(sink_class)
-
-        if other_sinks.any?
-          raise GetError, "Multiple sinks match: #{sink_class.inspect}"
-        end
-
-        sink
-      end
-
-      def get_sinks(sink_class)
-        sinks.select do |sink|
-          sink.instance_of?(sink_class)
-        end
-      end
-    end
-  end
-end

data/upstream-lib/test_bench_bootstrap/test_bench/telemetry.rb

@@ -1,18 +0,0 @@
-require 'json'
-
-require 'test_bench_bootstrap/test_bench/random'
-
-require 'test_bench_bootstrap/test_bench/telemetry/event_data'
-require 'test_bench_bootstrap/test_bench/telemetry/event_data/serialization'
-
-require 'test_bench_bootstrap/test_bench/telemetry/event'
-
-require 'test_bench_bootstrap/test_bench/telemetry/sink'
-require 'test_bench_bootstrap/test_bench/telemetry/sink/file'
-require 'test_bench_bootstrap/test_bench/telemetry/sink/handler/event_registry'
-require 'test_bench_bootstrap/test_bench/telemetry/sink/handler'
-
-require 'test_bench_bootstrap/test_bench/telemetry/telemetry'
-
-require 'test_bench_bootstrap/test_bench/telemetry/substitute/sink'
-require 'test_bench_bootstrap/test_bench/telemetry/substitute'