ld-eventsource 2.0.0.pre.beta.1 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: abed7a7f61d7f731895a05d722273996e683fab0
-  data.tar.gz: aa41fa22d28b66bd6bb6585f4030b06cb3b0dc05
+SHA256:
+  metadata.gz: 14623ca76eeb863804646a598dec0a4f368bdd4fbf8875b7d5bb1be62c1845bd
+  data.tar.gz: 9c9d521d4e10f01f93f04431acfbbe2821434e99dd2738c09726827a84a96ed2
 SHA512:
-  metadata.gz: 6597dfb8e3c7b1d4103ea18c44bb7d83a598b33565f79403fbec790d361c97ad1988b11027229e20cab4ec9e3895ad47faee37949eb1829a479d15b941f5d3e0
-  data.tar.gz: 910c3a810cc7534d316910dc06b95d311a3d22a659956a68d78c31a9f78b3210e9f019e94851e71b15e50271c74e1257735e1f57097d9c52f209acb82d837ac9
+  metadata.gz: 4fccea73f41283286656e7a8ad8d10c72e0175b68a34499008d38d897d9a8828000d3f9cdb582dca682e182d1d0045240d0522fd9e28e72401410aad668a603d
+  data.tar.gz: c0756a730b152c06e7a1497703d1acdc0216a9ad8938798914fda239011d34d4c5bf521d51f3cf4f06829e6830befb550d9a47bf6d9fa19bda9ee3e2ba08972b

data/README.md

@@ -10,7 +10,7 @@ Parts of this code are based on https://github.com/Tonkpils/celluloid-eventsourc
 Supported Ruby versions
 -----------------------
 
-This gem has a minimum Ruby version of 2.4, or 9.2 for JRuby.
+This gem has a minimum Ruby version of 2.5, or 9.2 for JRuby.
 
 Quick setup
 -----------

data/lib/ld-eventsource/client.rb

@@ -1,4 +1,5 @@
 require "ld-eventsource/impl/backoff"
+require "ld-eventsource/impl/buffered_line_reader"
 require "ld-eventsource/impl/event_parser"
 require "ld-eventsource/events"
 require "ld-eventsource/errors"
@@ -128,11 +129,12 @@ module SSE
           read: read_timeout,
           connect: connect_timeout
         })
-      @buffer = ""
+      @cxn = nil
       @lock = Mutex.new
 
       @backoff = Impl::Backoff.new(reconnect_time || DEFAULT_RECONNECT_TIME, MAX_RECONNECT_TIME,
         reconnect_reset_interval: reconnect_reset_interval)
+      @first_attempt = true
 
       @on = { event: ->(_) {}, error: ->(_) {} }
       @last_id = last_event_id
@@ -190,51 +192,27 @@ module SSE
       end
     end
 
+    #
+    # Tests whether the client has been shut down by a call to {Client#close}.
+    #
+    # @return [Boolean]  true if the client has been shut down
+    #
+    def closed?
+      @stopped.value
+    end
+
     private
     
     def reset_http
       @http_client.close if !@http_client.nil?
-      @cxn = nil
-      @buffer = ""
-    end
-    
-    def read_lines
-      Enumerator.new do |gen|
-        loop do
-          line = read_line
-          break if line.nil?
-          gen.yield line
-        end
-      end
-    end
-    
-    def read_line
-      loop do
-        @lock.synchronize do
-          i = @buffer.index(/[\r\n]/)
-          if !i.nil? && !(i == @buffer.length - 1 && @buffer[i] == "\r")
-            i += 1 if (@buffer[i] == "\r" && @buffer[i + 1] == "\n")
-            return @buffer.slice!(0, i + 1).force_encoding(Encoding::UTF_8)
-          end
-        end
-        return nil if !read_chunk_into_buffer
-      end
+      close_connection
     end
     
-    def read_chunk_into_buffer
-      # If @done is set, it means the Parser has signaled end of response body
-      @lock.synchronize { return false if @done }
-      begin
-        data = @cxn.readpartial
-      rescue HTTP::TimeoutError 
-        # We rethrow this as our own type so the caller doesn't have to know the httprb API
-        raise Errors::ReadTimeoutError.new(@read_timeout)
+    def close_connection
+      @lock.synchronize do
+        @cxn.connection.close if !@cxn.nil?
+        @cxn = nil
       end
-      return false if data == nil
-      @buffer << data
-      # We are piping the content through the parser so that it can handle things like chunked
-      # encoding for us. The content ends up being appended to @buffer via our callback.
-      true
     end
 
     def default_logger
@@ -246,13 +224,16 @@ module SSE
 
     def run_stream
       while !@stopped.value
-        @cxn = nil
+        close_connection
         begin
-          @cxn = connect
+          resp = connect
+          @lock.synchronize do
+            @cxn = resp
+          end
           # There's a potential race if close was called in the middle of the previous line, i.e. after we
           # connected but before @cxn was set. Checking the variable again is a bit clunky but avoids that.
           return if @stopped.value
-          read_stream(@cxn) if !@cxn.nil?
+          read_stream(resp) if !resp.nil?
         rescue => e
           # When we deliberately close the connection, it will usually trigger an exception. The exact type
           # of exception depends on the specific Ruby runtime. But @stopped will always be set in this case.
@@ -274,7 +255,8 @@ module SSE
     def connect
       loop do
         return if @stopped.value
-        interval = @backoff.next_interval
+        interval = @first_attempt ? 0 : @backoff.next_interval
+        @first_attempt = false
         if interval > 0
           @logger.info { "Will retry connection after #{'%.3f' % interval} seconds" } 
           sleep(interval)
@@ -317,7 +299,24 @@ module SSE
       # it can automatically reset itself if enough time passes between failures.
       @backoff.mark_success
 
-      event_parser = Impl::EventParser.new(read_lines)
+      chunks = Enumerator.new do |gen|
+        loop do
+          if @stopped.value
+            break
+          else
+            begin
+              data = cxn.readpartial
+            rescue HTTP::TimeoutError 
+              # For historical reasons, we rethrow this as our own type
+              raise Errors::ReadTimeoutError.new(@read_timeout)
+            end
+            break if data.nil?
+            gen.yield data
+          end
+        end
+      end
+      event_parser = Impl::EventParser.new(Impl::BufferedLineReader.lines_from(chunks))
+
       event_parser.items.each do |item|
         return if @stopped.value
         case item

data/lib/ld-eventsource/impl/buffered_line_reader.rb

@@ -0,0 +1,73 @@
+
+module SSE
+  module Impl
+    class BufferedLineReader
+      #
+      # Reads a series of data chunks from an enumerator, and returns an enumerator that
+      # parses/aggregates these into text lines. The line terminator may be CR, LF, or
+      # CRLF for each line; terminators are not included in the returned lines. When the
+      # input data runs out, the output enumerator ends and does not include any partially
+      # completed line.
+      #
+      # @param [Enumerator] chunks  an enumerator that will yield strings from a stream
+      # @return [Enumerator]  an enumerator that will yield one line at a time
+      #
+      def self.lines_from(chunks)
+        buffer = ""
+        position = 0
+        line_start = 0
+        last_char_was_cr = false
+
+        Enumerator.new do |gen|
+          chunks.each do |chunk|
+            buffer << chunk
+
+            loop do
+              # Search for a line break in any part of the buffer that we haven't yet seen.
+              i = buffer.index(/[\r\n]/, position)
+              if i.nil?
+                # There isn't a line break yet, so we'll keep accumulating data in the buffer, using
+                # position to keep track of where we left off scanning. We can also discard any previously
+                # parsed lines from the buffer at this point.
+                if line_start > 0
+                  buffer.slice!(0, line_start)
+                  line_start = 0
+                end
+                position = buffer.length
+                break
+              end
+
+              ch = buffer[i]
+              if i == 0 && ch == "\n" && last_char_was_cr
+                # This is just the dangling LF of a CRLF pair
+                last_char_was_cr = false
+                i += 1
+                position = i
+                line_start = i
+                next
+              end
+
+              line = buffer[line_start, i - line_start]
+              last_char_was_cr = false
+              i += 1
+              if ch == "\r"
+                if i == buffer.length
+                  last_char_was_cr = true # We'll break the line here, but be on watch for a dangling LF
+                elsif buffer[i] == "\n"
+                  i += 1
+                end
+              end
+              if i == buffer.length
+                buffer = ""
+                i = 0
+              end
+              position = i
+              line_start = i
+              gen.yield line
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ld-eventsource/impl/event_parser.rb

@@ -20,7 +20,8 @@ module SSE
       #
       # Constructs an instance of EventParser.
       #
-      # @param [Enumerator] lines  an enumerator that will yield one line of text at a time
+      # @param [Enumerator] lines  an enumerator that will yield one line of text at a time;
+      #   the lines should not include line terminators
       #
       def initialize(lines)
         @lines = lines
@@ -31,7 +32,6 @@ module SSE
       def items
         Enumerator.new do |gen|
           @lines.each do |line|
-            line.chomp!
             if line.empty?
               event = maybe_create_event
               reset_buffers
@@ -53,6 +53,7 @@ module SSE
         @id = nil
         @type = nil
         @data = ""
+        @have_data = false
       end
 
       def process_field(name, value)
@@ -60,8 +61,9 @@ module SSE
           when "event"
             @type = value.to_sym
           when "data"
-            @data << "\n" if !@data.empty?
+            @data << "\n" if @have_data
             @data << value
+            @have_data = true
           when "id"
             @id = value
           when "retry"
@@ -73,7 +75,7 @@ module SSE
       end
 
       def maybe_create_event
-        return nil if @data.empty?
+        return nil if !@have_data
         StreamEvent.new(@type || :message, @data, @id)
       end
     end

data/lib/ld-eventsource/version.rb

@@ -1,3 +1,3 @@
 module SSE
-  VERSION = "2.0.0-beta.1"
+  VERSION = "2.1.1"
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: ld-eventsource
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre.beta.1
+  version: 2.1.1
 platform: ruby
 authors:
 - LaunchDarkly
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-22 00:00:00.000000000 Z
+date: 2021-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: 2.2.10
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: 2.2.10
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
   requirement: !ruby/object:Gem::Requirement
@@ -70,16 +84,22 @@ dependencies:
   name: http
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 4.4.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 6.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 4.4.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 6.0.0
 description: LaunchDarkly SSE client for Ruby
 email:
 - team@launchdarkly.com
@@ -87,28 +107,16 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".circleci/config.yml"
-- ".gitignore"
-- ".ldrelease/config.yml"
-- CHANGELOG.md
-- Gemfile
-- Gemfile.lock
 - LICENSE
 - README.md
-- ld-eventsource.gemspec
 - lib/ld-eventsource.rb
 - lib/ld-eventsource/client.rb
 - lib/ld-eventsource/errors.rb
 - lib/ld-eventsource/events.rb
 - lib/ld-eventsource/impl/backoff.rb
+- lib/ld-eventsource/impl/buffered_line_reader.rb
 - lib/ld-eventsource/impl/event_parser.rb
 - lib/ld-eventsource/version.rb
-- scripts/gendocs.sh
-- scripts/release.sh
-- spec/backoff_spec.rb
-- spec/client_spec.rb
-- spec/event_parser_spec.rb
-- spec/http_stub.rb
 homepage: https://github.com/launchdarkly/ruby-eventsource
 licenses:
 - Apache-2.0
@@ -124,17 +132,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.3
+rubygems_version: 3.2.29
 signing_key: 
 specification_version: 4
 summary: LaunchDarkly SSE client
-test_files:
-- spec/backoff_spec.rb
-- spec/client_spec.rb
-- spec/event_parser_spec.rb
-- spec/http_stub.rb
+test_files: []

data/.circleci/config.yml

@@ -1,51 +0,0 @@
-version: 2
-
-workflows:
-  version: 2
-  test:
-    jobs:
-      - test-2.4
-      - test-2.5
-      - test-2.6
-      - test-2.7
-      - test-jruby-9.2
-
-ruby-docker-template: &ruby-docker-template
-  steps:
-    - checkout
-    - run: |
-        if [[ $CIRCLE_JOB == test-jruby* ]]; then
-          gem install jruby-openssl; # required by bundler, no effect on Ruby MRI
-        fi
-    - run: sudo apt-get update -y && sudo apt-get install -y build-essential
-    - run: ruby -v
-    - run: gem install bundler -v "~> 1.17"
-    - run: bundle install
-    - run: mkdir ./rspec
-    - run: bundle exec rspec --format progress --format RspecJunitFormatter -o ./rspec/rspec.xml spec
-    - store_test_results:
-        path: ./rspec
-    - store_artifacts:
-        path: ./rspec
-
-jobs:
-  test-2.4:
-    <<: *ruby-docker-template
-    docker:
-      - image: circleci/ruby:2.4
-  test-2.5:
-    <<: *ruby-docker-template
-    docker:
-      - image: circleci/ruby:2.5
-  test-2.6:
-    <<: *ruby-docker-template
-    docker:
-      - image: circleci/ruby:2.6
-  test-2.7:
-    <<: *ruby-docker-template
-    docker:
-      - image: circleci/ruby:2.7
-  test-jruby-9.2:
-    <<: *ruby-docker-template
-    docker:
-      - image: circleci/jruby:9.2-jdk

data/.gitignore

@@ -1,16 +0,0 @@
-/.bundle/
-/.yardoc
-/_yardoc/
-/coverage/
-/doc/
-/pkg/
-/spec/reports/
-/tmp/
-*.bundle
-*.so
-*.o
-*.a
-mkmf.log
-*.gem
-.DS_Store
-rspec

data/.ldrelease/config.yml

@@ -1,11 +0,0 @@
-repo:
-  public: ruby-eventsource
-
-publications:
-  - url: https://rubygems.org/gems/ld-eventsource
-    description: RubyGems
-  - url: https://www.rubydoc.info/gems/ld-eventsource
-    description: documentation
-
-template:
-  name: ruby

data/CHANGELOG.md

@@ -1,20 +0,0 @@
-# Change log
-
-All notable changes to the LaunchDarkly SSE Client for Ruby will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org).
-
-## [1.0.3] - 2020-03-17
-### Fixed:
-- The backoff delay logic for reconnecting after a stream failure was broken so that if a failure occurred after a stream had been active for at least `reconnect_reset_interval` (default 60 seconds), retries would use _no_ delay, potentially causing a flood of requests and a spike in CPU usage.
-
-## [1.0.2] - 2020-03-10
-### Removed:
-- Removed an unused dependency on `rake`. There are no other changes in this release.
-
-
-## [1.0.1] - 2019-07-10
-### Fixed:
-- Calling `close` on the client could cause a misleading warning message in the log, such as `Unexpected error from event source: #<IOError: stream closed in another thread>`.
-
-## [1.0.0] - 2019-01-03
-
-Initial release.

data/Gemfile

@@ -1,3 +0,0 @@
-source "https://rubygems.org"
-
-gemspec

data/Gemfile.lock

@@ -1,65 +0,0 @@
-PATH
-  remote: .
-  specs:
-    ld-eventsource (2.0.0.pre.beta.1)
-      concurrent-ruby (~> 1.0)
-      http (~> 4.4.1)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    addressable (2.7.0)
-      public_suffix (>= 2.0.2, < 5.0)
-    concurrent-ruby (1.1.8)
-    diff-lcs (1.3)
-    domain_name (0.5.20190701)
-      unf (>= 0.0.5, < 1.0.0)
-    ffi (1.14.2)
-    ffi (1.14.2-java)
-    ffi-compiler (1.0.1)
-      ffi (>= 1.0.0)
-      rake
-    http (4.4.1)
-      addressable (~> 2.3)
-      http-cookie (~> 1.0)
-      http-form_data (~> 2.2)
-      http-parser (~> 1.2.0)
-    http-cookie (1.0.3)
-      domain_name (~> 0.5)
-    http-form_data (2.3.0)
-    http-parser (1.2.3)
-      ffi-compiler (>= 1.0, < 2.0)
-    public_suffix (4.0.6)
-    rake (13.0.3)
-    rspec (3.7.0)
-      rspec-core (~> 3.7.0)
-      rspec-expectations (~> 3.7.0)
-      rspec-mocks (~> 3.7.0)
-    rspec-core (3.7.1)
-      rspec-support (~> 3.7.0)
-    rspec-expectations (3.7.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.7.0)
-    rspec-mocks (3.7.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.7.0)
-    rspec-support (3.7.0)
-    rspec_junit_formatter (0.3.0)
-      rspec-core (>= 2, < 4, != 2.12.0)
-    unf (0.1.4)
-      unf_ext
-    unf (0.1.4-java)
-    unf_ext (0.0.7.7)
-
-PLATFORMS
-  java
-  ruby
-
-DEPENDENCIES
-  bundler (~> 1.7)
-  ld-eventsource!
-  rspec (~> 3.2)
-  rspec_junit_formatter (~> 0.3.0)
-
-BUNDLED WITH
-   1.17.3

data/ld-eventsource.gemspec

@@ -1,29 +0,0 @@
-# coding: utf-8
-
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "ld-eventsource/version"
-
-# rubocop:disable Metrics/BlockLength
-Gem::Specification.new do |spec|
-  spec.name          = "ld-eventsource"
-  spec.version       = SSE::VERSION
-  spec.authors       = ["LaunchDarkly"]
-  spec.email         = ["team@launchdarkly.com"]
-  spec.summary       = "LaunchDarkly SSE client"
-  spec.description   = "LaunchDarkly SSE client for Ruby"
-  spec.homepage      = "https://github.com/launchdarkly/ruby-eventsource"
-  spec.license       = "Apache-2.0"
-
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
-
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rspec", "~> 3.2"
-  spec.add_development_dependency "rspec_junit_formatter", "~> 0.3.0"
-
-  spec.add_runtime_dependency "concurrent-ruby", "~> 1.0"
-  spec.add_runtime_dependency "http", "~> 4.4.1"
-end

data/scripts/gendocs.sh

@@ -1,12 +0,0 @@
-#!/bin/bash
-
-# Use this script to generate documentation locally in ./doc so it can be proofed before release.
-# After release, documentation will be visible at https://www.rubydoc.info/gems/ld-eventsource
-
-gem install --conservative yard
-gem install --conservative redcarpet  # provides Markdown formatting
-
-# yard doesn't seem to do recursive directories, even though Ruby's Dir.glob supposedly recurses for "**"
-PATHS="lib/*.rb lib/**/*.rb lib/**/**/*.rb"
-
-yard doc --no-private --markup markdown --markup-provider redcarpet --embed-mixins $PATHS - README.md

data/scripts/release.sh

@@ -1,30 +0,0 @@
-#!/usr/bin/env bash
-
-# This script updates the version for the library and releases it to RubyGems
-# It will only work if you have the proper credentials set up in ~/.gem/credentials
-
-# It takes exactly one argument: the new version.
-# It should be run from the root of this git repo like this:
-#   ./scripts/release.sh 4.0.9
-
-# When done you should commit and push the changes made.
-
-set -uxe
-
-VERSION=$1
-GEM_NAME=ld-eventsource
-
-echo "Starting $GEM_NAME release."
-
-# Update version in version.rb
-VERSION_RB_TEMP=./version.rb.tmp
-sed "s/VERSION =.*/VERSION = \"${VERSION}\"/g" lib/$GEM_NAME/version.rb > ${VERSION_RB_TEMP}
-mv ${VERSION_RB_TEMP} lib/$GEM_NAME/version.rb
-
-# Build Ruby gem
-gem build $GEM_NAME.gemspec
-
-# Publish Ruby gem
-gem push $GEM_NAME-${VERSION}.gem
-
-echo "Done with $GEM_NAME release"

data/spec/backoff_spec.rb

@@ -1,52 +0,0 @@
-require "ld-eventsource"
-
-require "http_stub"
-
-module SSE
-  module Impl
-    describe Backoff do
-      it "increases exponentially with jitter" do
-        initial = 1.5
-        max = 60
-        b = Backoff.new(initial, max)
-        previous = 0
-
-        for i in 1..6 do
-          interval = b.next_interval
-          expect(interval).to be > previous
-          target = initial * (2 ** (i - 1))
-          expect(interval).to be <= target
-          expect(interval).to be >= target / 2
-          previous = i
-        end
-
-        interval = b.next_interval
-        expect(interval).to be >= previous
-        expect(interval).to be <= max
-      end
-
-      it "resets to initial delay if reset threshold has elapsed" do
-        initial = 1.5
-        max = 60
-        threshold = 2
-        b = Backoff.new(initial, max, reconnect_reset_interval: threshold)
-
-        for i in 1..6 do
-          # just cause the backoff to increase quickly, don't actually do these delays
-          b.next_interval
-        end
-
-        b.mark_success
-        sleep(threshold + 0.001)
-
-        interval = b.next_interval
-        expect(interval).to be <= initial
-        expect(interval).to be >= initial / 2
-
-        interval = b.next_interval # make sure it continues increasing after that
-        expect(interval).to be <= (initial * 2)
-        expect(interval).to be >= initial
-      end
-    end
-  end
-end

data/spec/client_spec.rb

@@ -1,429 +0,0 @@
-require "ld-eventsource"
-
-#
-# End-to-end tests of the SSE client against a real server
-#
-describe SSE::Client do
-  subject { SSE::Client }
-
-  let(:simple_event_1) { SSE::StreamEvent.new(:go, "foo", "a")}
-  let(:simple_event_2) { SSE::StreamEvent.new(:stop, "bar", "b")}
-  let(:simple_event_1_text) { <<-EOT
-event: go
-data: foo
-id: a
-
-EOT
-  }
-  let(:simple_event_2_text) { <<-EOT
-event: stop
-data: bar
-id: b
-
-EOT
-  }
-  let(:reconnect_asap) { 0.01 }
-
-  def with_client(client)
-    begin
-      yield client
-    ensure
-      client.close
-    end
-  end
-
-  def send_stream_content(res, content, keep_open:)
-    res.content_type = "text/event-stream"
-    res.status = 200
-    res.chunked = true
-    rd, wr = IO.pipe
-    wr.write(content)
-    res.body = rd
-    if !keep_open
-      wr.close
-    end
-    wr
-  end
-
-  it "sends expected headers" do
-    with_server do |server|
-      requests = Queue.new
-      server.setup_response("/") do |req,res|
-        requests << req
-        send_stream_content(res, "", keep_open: true)
-      end
-      
-      headers = { "Authorization" => "secret" }
-
-      with_client(subject.new(server.base_uri, headers: headers)) do |client|
-        received_req = requests.pop
-        expect(received_req.header).to eq({
-          "accept" => ["text/event-stream"],
-          "cache-control" => ["no-cache"],
-          "host" => ["127.0.0.1:" + server.port.to_s],
-          "authorization" => ["secret"],
-          "user-agent" => ["ruby-eventsource"],
-          "content-length" => ["0"],
-          "connection" => ["close"]
-        })
-      end
-    end
-  end
-
-  it "sends initial Last-Event-Id if specified" do
-    id = "xyz"
-    with_server do |server|
-      requests = Queue.new
-      server.setup_response("/") do |req,res|
-        requests << req
-        send_stream_content(res, "", keep_open: true)
-      end
-      
-      headers = { "Authorization" => "secret" }
-
-      with_client(subject.new(server.base_uri, headers: headers, last_event_id: id)) do |client|
-        received_req = requests.pop
-        expect(received_req.header).to eq({
-          "accept" => ["text/event-stream"],
-          "cache-control" => ["no-cache"],
-          "host" => ["127.0.0.1:" + server.port.to_s],
-          "authorization" => ["secret"],
-          "last-event-id" => [id],
-          "user-agent" => ["ruby-eventsource"],
-          "content-length" => ["0"],
-          "connection" => ["close"]
-        })
-      end
-    end
-  end
-
-  it "receives messages" do
-    events_body = simple_event_1_text + simple_event_2_text
-    with_server do |server|
-      server.setup_response("/") do |req,res|
-        send_stream_content(res, events_body, keep_open: true)
-      end
-
-      event_sink = Queue.new
-      client = subject.new(server.base_uri) do |c|
-        c.on_event { |event| event_sink << event }
-      end
-
-      with_client(client) do |client|
-        expect(event_sink.pop).to eq(simple_event_1)
-        expect(event_sink.pop).to eq(simple_event_2)
-      end
-    end
-  end
-
-  it "does not trigger an error when stream is closed" do
-    events_body = simple_event_1_text + simple_event_2_text
-    with_server do |server|
-      server.setup_response("/") do |req,res|
-        send_stream_content(res, events_body, keep_open: true)
-      end
-
-      event_sink = Queue.new
-      error_sink = Queue.new
-      client = subject.new(server.base_uri) do |c|
-        c.on_event { |event| event_sink << event }
-        c.on_error { |error| error_sink << error }
-      end
-
-      with_client(client) do |client|
-        event_sink.pop  # wait till we have definitely started reading the stream
-        client.close
-        sleep 0.25  # there's no way to really know when the stream thread has finished
-        expect(error_sink.empty?).to be true
-      end
-    end
-  end
-
-  it "reconnects after error response" do
-    events_body = simple_event_1_text
-    with_server do |server|
-      attempt = 0
-      server.setup_response("/") do |req,res|
-        attempt += 1
-        if attempt == 1
-          res.status = 500
-          res.body = "sorry"
-          res.keep_alive = false
-        else
-          send_stream_content(res, events_body, keep_open: true)
-        end
-      end
-
-      event_sink = Queue.new
-      error_sink = Queue.new
-      client = subject.new(server.base_uri, reconnect_time: reconnect_asap) do |c|
-        c.on_event { |event| event_sink << event }
-        c.on_error { |error| error_sink << error }
-      end
-
-      with_client(client) do |client|
-        expect(event_sink.pop).to eq(simple_event_1)
-        expect(error_sink.pop).to eq(SSE::Errors::HTTPStatusError.new(500, "sorry"))
-        expect(attempt).to eq 2
-      end
-    end
-  end
-
-  it "reconnects after invalid content type" do
-    events_body = simple_event_1_text
-    with_server do |server|
-      attempt = 0
-      server.setup_response("/") do |req,res|
-        attempt += 1
-        if attempt == 1
-          res.status = 200
-          res.content_type = "text/plain"
-          res.body = "sorry"
-          res.keep_alive = false
-        else
-          send_stream_content(res, events_body, keep_open: true)
-        end
-      end
-
-      event_sink = Queue.new
-      error_sink = Queue.new
-      client = subject.new(server.base_uri, reconnect_time: reconnect_asap) do |c|
-        c.on_event { |event| event_sink << event }
-        c.on_error { |error| error_sink << error }
-      end
-
-      with_client(client) do |client|
-        expect(event_sink.pop).to eq(simple_event_1)
-        expect(error_sink.pop).to eq(SSE::Errors::HTTPContentTypeError.new("text/plain"))
-        expect(attempt).to eq 2
-      end
-    end
-  end
-
-  it "reconnects after read timeout" do
-    events_body = simple_event_1_text
-    with_server do |server|
-      attempt = 0
-      server.setup_response("/") do |req,res|
-        attempt += 1
-        if attempt == 1
-          sleep(1)
-        end
-        send_stream_content(res, events_body, keep_open: true)
-      end
-
-      event_sink = Queue.new
-      client = subject.new(server.base_uri, reconnect_time: reconnect_asap, read_timeout: 0.25) do |c|
-        c.on_event { |event| event_sink << event }
-      end
-
-      with_client(client) do |client|
-        expect(event_sink.pop).to eq(simple_event_1)
-        expect(attempt).to eq 2
-      end
-    end
-  end
-
-  it "reconnects if stream returns EOF" do
-    with_server do |server|
-      attempt = 0
-      server.setup_response("/") do |req,res|
-        attempt += 1
-        send_stream_content(res, attempt == 1 ? simple_event_1_text : simple_event_2_text,
-          keep_open: attempt == 2)
-      end
-
-      event_sink = Queue.new
-      client = subject.new(server.base_uri, reconnect_time: reconnect_asap) do |c|
-        c.on_event { |event| event_sink << event }
-      end
-
-      with_client(client) do |client|
-        expect(event_sink.pop).to eq(simple_event_1)
-        expect(event_sink.pop).to eq(simple_event_2)
-        expect(attempt).to eq 2
-      end
-    end
-  end
-
-  it "sends ID of last received event, if any, when reconnecting" do
-    with_server do |server|
-      requests = Queue.new
-      attempt = 0
-      server.setup_response("/") do |req,res|
-        requests << req
-        attempt += 1
-        send_stream_content(res, attempt == 1 ? simple_event_1_text : simple_event_2_text,
-          keep_open: attempt == 2)
-      end
-
-      event_sink = Queue.new
-      client = subject.new(server.base_uri, reconnect_time: reconnect_asap) do |c|
-        c.on_event { |event| event_sink << event }
-      end
-
-      with_client(client) do |client|
-        req1 = requests.pop
-        req2 = requests.pop
-        expect(req2.header["last-event-id"]).to eq([ simple_event_1.id ])
-      end
-    end
-  end
-
-  it "increases backoff delay if a failure happens within the reset threshold" do
-    request_times = []
-    max_requests = 5
-    initial_interval = 0.25
-
-    with_server do |server|
-      attempt = 0
-      server.setup_response("/") do |req,res|
-        request_times << Time.now
-        attempt += 1
-        send_stream_content(res, simple_event_1_text, keep_open: attempt == max_requests)
-      end
-
-      event_sink = Queue.new
-      client = subject.new(server.base_uri, reconnect_time: initial_interval) do |c|
-        c.on_event { |event| event_sink << event }
-      end
-
-      with_client(client) do |client|
-        last_interval = nil
-        max_requests.times do |i|
-          expect(event_sink.pop).to eq(simple_event_1)
-          if i > 0
-            interval = request_times[i] - request_times[i - 1]
-            minimum_expected_interval = initial_interval * (2 ** (i - 1)) / 2
-            expect(interval).to be >= minimum_expected_interval
-            last_interval = interval
-          end
-        end
-      end
-    end
-  end
-
-  it "resets backoff delay if a failure happens after the reset threshold" do
-    request_times = []
-    request_end_times = []
-    max_requests = 5
-    threshold = 0.3
-    initial_interval = 0.25
-
-    with_server do |server|
-      attempt = 0
-      server.setup_response("/") do |req,res|
-        request_times << Time.now
-        attempt += 1
-        stream = send_stream_content(res, simple_event_1_text, keep_open: true)
-        Thread.new do
-          sleep(threshold + 0.01)
-          stream.close
-          request_end_times << Time.now
-        end
-      end
-
-      event_sink = Queue.new
-      client = subject.new(server.base_uri, reconnect_time: initial_interval, reconnect_reset_interval: threshold) do |c|
-        c.on_event { |event| event_sink << event }
-      end
-
-      with_client(client) do |client|
-        last_interval = nil
-        max_requests.times do |i|
-          expect(event_sink.pop).to eq(simple_event_1)
-          if i > 0
-            interval = request_times[i] - request_end_times[i - 1]
-            expect(interval).to be <= (initial_interval + 0.1)
-          end
-        end
-      end
-    end
-  end
-
-  it "can change initial reconnect delay based on directive from server" do
-    request_times = []
-    configured_interval = 1
-    retry_ms = 100
-
-    with_server do |server|
-      attempt = 0
-      server.setup_response("/") do |req,res|
-        request_times << Time.now
-        attempt += 1
-        if attempt == 1
-          send_stream_content(res, "retry: #{retry_ms}\n", keep_open: false)
-        else
-          send_stream_content(res, simple_event_1_text, keep_open: true)
-        end
-      end
-
-      event_sink = Queue.new
-      client = subject.new(server.base_uri, reconnect_time: configured_interval) do |c|
-        c.on_event { |event| event_sink << event }
-      end
-
-      with_client(client) do |client|
-        expect(event_sink.pop).to eq(simple_event_1)
-        interval = request_times[1] - request_times[0]
-        expect(interval).to be < 0.5
-      end
-    end
-  end
-
-  it "connects to HTTP server through proxy" do
-    events_body = simple_event_1_text
-    with_server do |server|
-      server.setup_response("/") do |req,res|
-        send_stream_content(res, events_body, keep_open: false)
-      end
-      with_server(StubProxyServer.new) do |proxy|
-        event_sink = Queue.new
-        client = subject.new(server.base_uri, proxy: proxy.base_uri) do |c|
-          c.on_event { |event| event_sink << event }
-        end
-
-        with_client(client) do |client|
-          expect(event_sink.pop).to eq(simple_event_1)
-          expect(proxy.request_count).to eq(1)
-        end
-      end
-    end
-  end
-
-  it "resets read timeout between events" do
-    event_body = simple_event_1_text
-    with_server do |server|
-      attempt = 0
-      server.setup_response("/") do |req,res|
-        attempt += 1
-        if attempt == 1
-          stream = send_stream_content(res, event_body, keep_open: true)
-          Thread.new do
-            2.times {
-              # write within timeout interval
-              sleep(0.75)
-              stream.write(event_body)
-            }
-            # cause timeout
-            sleep(1.25)
-          end
-        elsif attempt == 2
-          send_stream_content(res, event_body, keep_open: false)
-        end
-      end
-
-      event_sink = Queue.new
-      client = subject.new(server.base_uri, reconnect_time: reconnect_asap, read_timeout: 1) do |c|
-        c.on_event { |event| event_sink << event }
-      end
-
-      with_client(client) do |client|
-        4.times {
-          expect(event_sink.pop).to eq(simple_event_1)
-        }
-        expect(attempt).to eq 2
-      end
-    end
-  end
-end

data/spec/event_parser_spec.rb

@@ -1,100 +0,0 @@
-require "ld-eventsource/impl/event_parser"
-
-describe SSE::Impl::EventParser do
-  subject { SSE::Impl::EventParser }
-
-  it "parses an event with all fields" do
-    lines = [
-      "event: abc\r\n",
-      "data: def\r\n",
-      "id: 1\r\n",
-      "\r\n"
-    ]
-    ep = subject.new(lines)
-    
-    expected_event = SSE::StreamEvent.new(:abc, "def", "1")
-    output = ep.items.to_a
-    expect(output).to eq([ expected_event ])
-  end
-
-  it "parses an event with only data" do
-    lines = [
-      "data: def\r\n",
-      "\r\n"
-    ]
-    ep = subject.new(lines)
-    
-    expected_event = SSE::StreamEvent.new(:message, "def", nil)
-    output = ep.items.to_a
-    expect(output).to eq([ expected_event ])
-  end
-
-  it "parses an event with multi-line data" do
-    lines = [
-      "data: def\r\n",
-      "data: ghi\r\n",
-      "\r\n"
-    ]
-    ep = subject.new(lines)
-    
-    expected_event = SSE::StreamEvent.new(:message, "def\nghi", nil)
-    output = ep.items.to_a
-    expect(output).to eq([ expected_event ])
-  end
-
-  it "ignores comments" do
-    lines = [
-      ":",
-      "data: def\r\n",
-      ":",
-      "\r\n"
-    ]
-    ep = subject.new(lines)
-    
-    expected_event = SSE::StreamEvent.new(:message, "def", nil)
-    output = ep.items.to_a
-    expect(output).to eq([ expected_event ])
-  end
-
-  it "parses reconnect interval" do
-    lines = [
-      "retry: 2500\r\n",
-      "\r\n"
-    ]
-    ep = subject.new(lines)
-
-    expected_item = SSE::Impl::SetRetryInterval.new(2500)
-    output = ep.items.to_a
-    expect(output).to eq([ expected_item ])
-  end
-
-  it "parses multiple events" do
-    lines = [
-      "event: abc\r\n",
-      "data: def\r\n",
-      "id: 1\r\n",
-      "\r\n",
-      "data: ghi\r\n",
-      "\r\n"
-    ]
-    ep = subject.new(lines)
-    
-    expected_event_1 = SSE::StreamEvent.new(:abc, "def", "1")
-    expected_event_2 = SSE::StreamEvent.new(:message, "ghi", nil)
-    output = ep.items.to_a
-    expect(output).to eq([ expected_event_1, expected_event_2 ])
-  end
-
-  it "ignores events with no data" do
-    lines = [
-      "event: nothing\r\n",
-      "\r\n",
-      "event: nada\r\n",
-      "\r\n"
-    ]
-    ep = subject.new(lines)
-    
-    output = ep.items.to_a
-    expect(output).to eq([])
-  end
-end

data/spec/http_stub.rb

@@ -1,83 +0,0 @@
-require "webrick"
-require "webrick/httpproxy"
-require "webrick/https"
-
-class StubHTTPServer
-  attr_reader :port
-
-  def initialize
-    @port = 50000
-    begin
-      @server = create_server(@port)
-    rescue Errno::EADDRINUSE
-      @port += 1
-      retry
-    end
-  end
-
-  def create_server(port)
-    WEBrick::HTTPServer.new(
-      BindAddress: '127.0.0.1',
-      Port: port,
-      AccessLog: [],
-      Logger: NullLogger.new
-    )
-  end
-
-  def start
-    Thread.new { @server.start }
-  end
-
-  def stop
-    @server.shutdown
-  end
-
-  def base_uri
-    URI("http://127.0.0.1:#{@port}")
-  end
-
-  def setup_response(uri_path, &action)
-    @server.mount_proc(uri_path, action)
-  end
-end
-
-class StubProxyServer < StubHTTPServer
-  attr_reader :request_count
-  attr_accessor :connect_status
-
-  def initialize
-    super
-    @request_count = 0
-  end
-
-  def create_server(port)
-    WEBrick::HTTPProxyServer.new(
-      BindAddress: '127.0.0.1',
-      Port: port,
-      AccessLog: [],
-      Logger: NullLogger.new,
-      ProxyContentHandler: proc do |req,res|
-        if !@connect_status.nil?
-          res.status = @connect_status
-        end
-        @request_count += 1
-      end
-    )
-  end
-end
-
-class NullLogger
-  def method_missing(*)
-    self
-  end
-end
-
-def with_server(server = nil)
-  server = StubHTTPServer.new if server.nil?
-  begin
-    server.start
-    yield server
-  ensure
-    server.stop
-  end
-end