exceptional_synchrony 1.1.1 → 1.4.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 883532dc8502a497eabb0785806a621f034463c021e676526ff70a5c4119d5c1
-  data.tar.gz: 927c40e91113f1c0fb6828f400253c18fa6abcb1fec772327913a966a21fdc9c
+  metadata.gz: 23aa4209588ee0dc66a1c96e25d1a524e1191f7d6f46a0acdfae90c04f19bf93
+  data.tar.gz: 1c40477122edb3b80bdfae312e486ef8a85cf4bac2c9ee78793e6de97bd72b5e
 SHA512:
-  metadata.gz: eb19bc5fbcdd191ef8ea84acb72fae37c8b32a042fccfa15de3e6b0b41d9f6fc5a7d3a4aa488da6d337e60bf6f1ca93b9e1ff948c3ed2e4f948b92b576fc1a76
-  data.tar.gz: 9ea68a7d671a07e59a09b4cf56c99562db38b83decd54b7399e45a54e8f7ac7fedca70c5e20ab319b90a054dda758eed701497683b9b5f39f0fd52ee79c3b590
+  metadata.gz: 3fec9e8a041a72ee6c521d1ffb33eeef2a470c3df92b41dacaf7c57d6aa33fe0e3d2ee85392f68261c6ed00e29c0264f809dee303ba896bfc471682f161f2303
+  data.tar.gz: 04d48f19f25bcae51e5b97bf318f78c44151b3d3417dac6b536f25f7b2d778736de0b226aa80c540fbd14801c587c2ffd80e0f4c2890c2ef7003f46fb24f5add

data/.gitignore

@@ -34,6 +34,7 @@ intermediate
 publish
 .bundle
 pkg/
+test/reports
 
 # Vim
 *.s[a-w][a-z]

data/.jenkins/Jenkinsfile

@@ -0,0 +1,58 @@
+#!/usr/bin/groovy
+@Library('jenkins-pipeline@v0.4.5')
+import com.invoca.docker.*;
+pipeline {
+  agent {
+    kubernetes {
+      defaultContainer "ruby"
+      yamlFile ".jenkins/ruby_build_pod.yml"
+    }
+  }
+
+  environment {
+    GITHUB_TOKEN = credentials('github_token')
+    GITHUB_KEY = credentials('github_key')
+    BUNDLE_GEM__FURY__IO = credentials('gemfury_deploy_token')
+  }
+
+  stages {
+    stage('Setup') {
+      steps {
+        updateGitHubStatus('clean-build', 'pending', 'Unit tests.')
+        script {
+          sh '''
+            # get SSH setup inside the container
+            eval `ssh-agent -s`
+            echo "$GITHUB_KEY" | ssh-add -
+            mkdir -p /root/.ssh
+            ssh-keyscan -t rsa github.com > /root/.ssh/known_hosts
+            bundle install
+          '''        }
+      }
+    }
+    stage('Unit Test') {
+      steps {
+        script {
+          sh 'bundle exec rake'
+        }
+      }
+      post {
+        always { junit '*/reports/*.xml' }
+        success { updateGitHubStatus('clean-build', 'success', 'Unit tests.') }
+        failure { updateGitHubStatus('clean-build', 'failure', 'Unit tests.') }
+      }
+    }
+  }
+}
+
+void updateGitHubStatus(String context, String status, String description) {
+  gitHubStatus([
+    repoSlug:    'Invoca/exceptional_synchrony',
+    sha:         env.GIT_COMMIT,
+    description: description,
+    context:     context,
+    targetURL:   env.RUN_DISPLAY_URL,
+    token:       env.GITHUB_TOKEN,
+    status:      status
+  ])
+}

data/.jenkins/ruby_build_pod.yml

@@ -0,0 +1,19 @@
+---
+apiVersion: v1
+kind: Pod
+metadata:
+  labels:
+  jenkins/exceptional-synchrony: 'true'
+  namespace: jenkins
+  name: exceptional-synchrony
+spec:
+  containers:
+  - name: ruby
+    image: ruby:2.6.5
+    tty: true
+    resources:
+    requests:
+      memory: "100Mi"
+    command:
+      - cat
+

data/CHANGELOG.md

@@ -1,11 +1,34 @@
-# CHANGELOG for `exceptional_synchrony`
+# CHANGELOG for `exception_synchrony`
 
 Inspired by [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 Note: This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 All notable changes to this project will be documented in this file.
+
+## [1.4.0] - UNRELEASED
+### Added
+- For users of `Faraday` connections, its `default_adapter` is configured to `:em_synchrony` when starting
+  the `EventMachine` reactor so that the reactor does not get blocked when using `Faraday`
+
+## [1.3.0] - 2021-02-04
+### Added
+- Extend `EMP.defer` to have a new keyword argument, `wait_for_result` for the callers to control whether they should should block until the background thread returns. To preserve existing behavior, this option defaults to `true`, so `EMP.defer` will block in order to return the value (or raise an exception) from the deferred block. Callers can pass `wait_for_result: false` if they do not want to block.
+
+## [1.2.0] - 2020-06-02
+### Changed
+- If `EMP.run` rescues an exception, previous versions would simply log the exception and continue.
+  Instead this version has an `on_error` option with possible values `:log` and `:raise`.
+  It defaults to `:log` and in that case, as before, logs any rescued `StandardError` exception and continues.
+  When `on_error` is set to `:raise`, the method raises a `FatalRunError` wrapper around the rescued exception.
+  This `FatalRunError` exception does not derive from `StandardError`, so it will not be erroneously rescued by any
+  registered `EMP.error_handler`. Instead it should be rescued at the outer edge of the process.
+  We expect that outer edge handler to log the exception chain (the wrapper plus nested `cause` exception(s))
+  and exit the process with a non-0 status code.
+
 ## [1.1.1] - 2020-05-03
 - Replace hobo_support with invoca_utils
 
+[1.3.0]: https://github.com/Invoca/exceptional_synchrony/compare/v1.2.0...v1.3.0
+[1.2.0]: https://github.com/Invoca/exceptional_synchrony/compare/v1.1.1...v1.2.0
 [1.1.1]: https://github.com/Invoca/exceptional_synchrony/compare/v1.1.0...v1.1.1

data/Gemfile

@@ -7,6 +7,7 @@ gemspec
 
 group :development do
   gem 'minitest'
+  gem 'minitest-reporters'
   gem 'pry'
   gem 'rake'
   gem 'rr',      '~> 1.2'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    exceptional_synchrony (1.1.1)
+    exceptional_synchrony (1.4.0.pre.1)
       em-http-request
       em-synchrony
       eventmachine
@@ -11,46 +11,49 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    actionmailer (4.2.11.1)
-      actionpack (= 4.2.11.1)
-      actionview (= 4.2.11.1)
-      activejob (= 4.2.11.1)
+    actionmailer (6.1.1)
+      actionpack (= 6.1.1)
+      actionview (= 6.1.1)
+      activejob (= 6.1.1)
+      activesupport (= 6.1.1)
       mail (~> 2.5, >= 2.5.4)
-      rails-dom-testing (~> 1.0, >= 1.0.5)
-    actionpack (4.2.11.1)
-      actionview (= 4.2.11.1)
-      activesupport (= 4.2.11.1)
-      rack (~> 1.6)
-      rack-test (~> 0.6.2)
-      rails-dom-testing (~> 1.0, >= 1.0.5)
-      rails-html-sanitizer (~> 1.0, >= 1.0.2)
-    actionview (4.2.11.1)
-      activesupport (= 4.2.11.1)
+      rails-dom-testing (~> 2.0)
+    actionpack (6.1.1)
+      actionview (= 6.1.1)
+      activesupport (= 6.1.1)
+      rack (~> 2.0, >= 2.0.9)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.2.0)
+    actionview (6.1.1)
+      activesupport (= 6.1.1)
       builder (~> 3.1)
-      erubis (~> 2.7.0)
-      rails-dom-testing (~> 1.0, >= 1.0.5)
-      rails-html-sanitizer (~> 1.0, >= 1.0.3)
-    activejob (4.2.11.1)
-      activesupport (= 4.2.11.1)
-      globalid (>= 0.3.0)
-    activesupport (4.2.11.1)
-      i18n (~> 0.7)
-      minitest (~> 5.1)
-      thread_safe (~> 0.3, >= 0.3.4)
-      tzinfo (~> 1.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activejob (6.1.1)
+      activesupport (= 6.1.1)
+      globalid (>= 0.3.6)
+    activesupport (6.1.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
     addressable (2.7.0)
       public_suffix (>= 2.0.2, < 5.0)
+    ansi (1.5.0)
     builder (3.2.4)
     coderay (1.1.2)
-    concurrent-ruby (1.1.6)
-    contextual_logger (0.6.1)
+    concurrent-ruby (1.1.8)
+    contextual_logger (0.11.0)
       activesupport
       json
     cookiejar (0.3.3)
     crack (0.4.3)
       safe_yaml (~> 1.0.0)
     crass (1.0.6)
-    em-http-request (1.1.5)
+    em-http-request (1.1.7)
       addressable (>= 2.3.4)
       cookiejar (!= 0.3.1)
       em-socksify (>= 0.3)
@@ -60,60 +63,65 @@ GEM
       eventmachine (>= 1.0.0.beta.4)
     em-synchrony (1.0.6)
       eventmachine (>= 1.0.0.beta.1)
-    erubis (2.7.0)
+    erubi (1.10.0)
     eventmachine (1.2.7)
-    exception_handling (2.4.1)
-      actionmailer (~> 4.2)
-      actionpack (~> 4.2)
-      activesupport (~> 4.2)
-      contextual_logger
+    exception_handling (2.8.1)
+      actionmailer (>= 4.2, < 7.0)
+      actionpack (>= 4.2, < 7.0)
+      activesupport (>= 4.2, < 7.0)
+      contextual_logger (~> 0.7)
       eventmachine (~> 1.0)
       invoca-utils (~> 0.3)
     globalid (0.4.2)
       activesupport (>= 4.2.0)
     hashdiff (1.0.1)
     http_parser.rb (0.6.0)
-    i18n (0.9.5)
+    i18n (1.8.8)
       concurrent-ruby (~> 1.0)
-    invoca-utils (0.3.0)
-    json (2.3.0)
-    loofah (2.5.0)
+    invoca-utils (0.4.1)
+    json (2.5.1)
+    loofah (2.9.0)
       crass (~> 1.0.2)
       nokogiri (>= 1.5.9)
     mail (2.7.1)
       mini_mime (>= 0.1.1)
     method_source (1.0.0)
     mini_mime (1.0.2)
-    mini_portile2 (2.4.0)
+    mini_portile2 (2.5.0)
     minitest (5.14.0)
-    nokogiri (1.10.9)
-      mini_portile2 (~> 2.4.0)
+    minitest-reporters (1.4.2)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    nokogiri (1.11.1)
+      mini_portile2 (~> 2.5.0)
+      racc (~> 1.4)
     pry (0.13.1)
       coderay (~> 1.1)
       method_source (~> 1.0)
     public_suffix (4.0.4)
-    rack (1.6.13)
-    rack-test (0.6.3)
-      rack (>= 1.0)
-    rails-deprecated_sanitizer (1.0.3)
-      activesupport (>= 4.2.0.alpha)
-    rails-dom-testing (1.0.9)
-      activesupport (>= 4.2.0, < 5.0)
-      nokogiri (~> 1.6)
-      rails-deprecated_sanitizer (>= 1.0.1)
+    racc (1.5.2)
+    rack (2.2.3)
+    rack-test (1.1.0)
+      rack (>= 1.0, < 3)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
     rails-html-sanitizer (1.3.0)
       loofah (~> 2.3)
     rake (13.0.1)
     rr (1.2.1)
+    ruby-progressbar (1.10.1)
     safe_yaml (1.0.5)
     thor (1.0.1)
-    thread_safe (0.3.6)
-    tzinfo (1.2.7)
-      thread_safe (~> 0.1)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
     webmock (1.24.6)
       addressable (>= 2.3.6)
       crack (>= 0.3.2)
       hashdiff
+    zeitwerk (2.4.2)
 
 PLATFORMS
   ruby
@@ -121,6 +129,7 @@ PLATFORMS
 DEPENDENCIES
   exceptional_synchrony!
   minitest
+  minitest-reporters
   pry
   rake
   rr (~> 1.2)

data/Rakefile

@@ -7,6 +7,7 @@ require 'rake/testtask'
 task default: :test
 
 Rake::TestTask.new do |t|
+  t.warning = false
   t.pattern = "test/**/*_test.rb"
 end
 

data/lib/exceptional_synchrony/event_machine_proxy.rb

@@ -5,6 +5,10 @@ require 'em-http'
 require 'em-synchrony/em-http'
 
 module ExceptionalSynchrony
+  # It is important for this exception to be inherited from Exception so that
+  # when thrown it does not get caught by the EventMachine.error_handler.
+  class FatalRunError < Exception; end
+
   class EventMachineProxy
 
     attr_reader :connection
@@ -60,30 +64,41 @@ module ExceptionalSynchrony
       @proxy_class.next_tick { } #Fake out EventMachine's epoll mechanism so we don't block until timers fire
     end
 
+    def defers_finished?
+      @proxy_class.defers_finished?
+    end
+
     def connect(server, port = nil, handler = nil, *args, &block)
       @proxy_class.connect(server, port, handler, *args, &block)
     end
 
-    def run(&block)
-      ensure_completely_safe("run") do
-        if @proxy_class.respond_to?(:synchrony)
-          @proxy_class.synchrony(&block)
-        else
-          @proxy_class.run(&block)
-        end
+    # The on_error option has these possible values:
+    #   :log   - log any rescued StandardError exceptions and continue
+    #   :raise - raise FatalRunError for any rescued StandardError exceptions
+    def run(on_error: :log, &block)
+      configure_faraday
+      case on_error
+      when :log   then run_with_error_logging(&block)
+      when :raise then run_with_error_raising(&block)
+      else raise ArgumentError, "Invalid on_error: #{on_error.inspect}, must be :log or :raise"
       end
     end
 
-    def defer(context, &block)
-      deferrable = EventMachine::DefaultDeferrable.new
-
-      callback = -> (result) { deferrable.succeed(result) }
-
-      EventMachine.defer(nil, callback) { CallbackExceptions.return_exception(&block) }
-
-      EventMachine::Synchrony.sync(deferrable)
-
-      CallbackExceptions.map_deferred_result(deferrable)
+    # This method will execute the block on the background thread pool
+    # By default, it will block the caller until the background thread has finished, so that the result can be returned
+    #  :wait_for_result - setting this to false will prevent the caller from being blocked by this deferred work
+    def defer(context, wait_for_result: true, &block)
+      if wait_for_result
+        deferrable = EventMachine::DefaultDeferrable.new
+        callback = -> (result) { deferrable.succeed(result) }
+
+        EventMachine.defer(nil, callback) { CallbackExceptions.return_exception(&block) }
+        EventMachine::Synchrony.sync(deferrable)
+        CallbackExceptions.map_deferred_result(deferrable)
+      else
+        EventMachine.defer { ExceptionHandling.ensure_completely_safe("defer", &block) }
+        nil
+      end
     end
 
     def reactor_running?
@@ -108,6 +123,44 @@ module ExceptionalSynchrony
         yield
       end
     end
+
+    def rescue_exceptions_and_ensure_exit(context)
+      yield
+    rescue StandardError => ex
+      # Raise a non-StandardError so that not caught by EM.error_handler.
+      # Expecting rescued exception to be stored in this new exception's cause.
+      raise FatalRunError, "Fatal EventMachine #{context} error\n#{ex.class.name}: #{ex.message}"
+    end
+
+    private
+
+    def configure_faraday
+      if defined?(Faraday)
+        Faraday.default_adapter = :em_synchrony
+      end
+    end
+
+    def run_with_error_logging(&block)
+      ensure_completely_safe("run_with_error_logging") do
+        if @proxy_class.respond_to?(:synchrony)
+          @proxy_class.synchrony(&block)
+        else
+          @proxy_class.run(&block)
+        end
+      end
+    end
+
+    def run_with_error_raising(&block)
+      run_block = -> { rescue_exceptions_and_ensure_exit("run_with_error_raising", &block) }
+
+      rescue_exceptions_and_ensure_exit("run_with_error_raising") do
+        if @proxy_class.respond_to?(:synchrony)
+          @proxy_class.synchrony(&run_block)
+        else
+          @proxy_class.run(&run_block)
+        end
+      end
+    end
   end
 
   EMP = EventMachineProxy.new(EventMachine, EventMachine::HttpRequest)

data/lib/exceptional_synchrony/version.rb

@@ -1,3 +1,3 @@
 module ExceptionalSynchrony
-  VERSION = '1.1.1'
+  VERSION = '1.4.0.pre.1'
 end

data/test/test_helper.rb

@@ -7,6 +7,11 @@ require_relative '../lib/exceptional_synchrony.rb'
 
 require 'minitest/autorun' or raise "Already loaded minitest?"
 require 'minitest/pride'
+require 'minitest/reporters'
+Minitest::Reporters.use! [
+  Minitest::Reporters::DefaultReporter.new,
+  Minitest::Reporters::JUnitReporter.new
+]
 require 'webmock'
 require 'webmock/minitest'
 require 'rr'

data/test/unit/event_machine_proxy_test.rb

@@ -3,10 +3,39 @@ require_relative '../test_helper'
 describe ExceptionalSynchrony::EventMachineProxy do
   include TestHelper
 
+  class RunProxyMock
+    class << self
+      def run(&block)
+        block.call
+        :run
+      end
+
+      def error_handler
+      end
+    end
+  end
+
+  class SynchronyProxyMock < RunProxyMock
+    class << self
+      def synchrony(&block)
+        block.call
+        :synchrony
+      end
+    end
+  end
+
+  def stop_em_after_defers_finish!(em)
+    check_finished_counter = 0
+    em.add_periodic_timer(0.1) do
+      (check_finished_counter += 1) > 20 and raise "defer never finished!"
+      em.defers_finished? and em.stop
+    end
+  end
+
   before do
     @em = ExceptionalSynchrony::EventMachineProxy.new(EventMachine, nil)
     @yielded_value = nil
-    @block = lambda { |value| @yielded_value = value }
+    @block = -> (value) { @yielded_value = value }
   end
 
   it "should proxy add_timer" do
@@ -57,18 +86,41 @@ describe ExceptionalSynchrony::EventMachineProxy do
   end
 
   describe "#defer" do
-    it "should output its block's output when it doesn't raise an error" do
-      ExceptionHandling.logger = Logger.new(STDERR)
+    before do
+      logger = Logger.new(STDERR)
+      logger.extend ContextualLogger::LoggerMixin
+      ExceptionHandling.logger = logger
+    end
 
+    it "should output its block's output when it doesn't raise an error, by default" do
       @em.run do
         assert_equal 12, @em.defer("#defer success") { 12 }
         @em.stop
       end
     end
 
-    it "should raise an error when its block raises an error" do
-      ExceptionHandling.logger = Logger.new(STDERR)
+    it "should not wait for its block to run if option is passed" do
+      @block_ran = false
+
+      @em.run do
+        assert_nil @em.defer("#defer success", wait_for_result: false) { @block_ran = true; 12 }
+        refute @block_ran
+        stop_em_after_defers_finish!(@em)
+      end
+
+      assert @block_ran
+    end
+
+    it "should handle exceptions when not waiting for its block to run" do
+      mock(ExceptionHandling).log_error(is_a(RuntimeError), "defer", {})
 
+      @em.run do
+        assert_nil @em.defer("#defer success", wait_for_result: false) { raise RuntimeError, "error in defer" }
+        stop_em_after_defers_finish!(@em)
+      end
+    end
+
+    it "should raise an error when its block raises an error" do
       @em.run do
         ex = assert_raises(ArgumentError) do
           @em.defer("#defer raising an error") { raise ArgumentError, "!!!" }
@@ -106,27 +158,71 @@ describe ExceptionalSynchrony::EventMachineProxy do
     end
   end
 
-  [false, true].each do |synchrony|
-    describe "synchrony = #{synchrony}" do
-      it "should dispatch to the proxy's synchrony method instead of run iff synchrony" do
-        proxy_mock = Struct.new(:proxy, :class_connection) do
-          if synchrony
-            def self.synchrony(&block)
-              block.(:synchrony)
-            end
+  describe "run with faraday" do
+    it "should conigure Faraday default_adapter to :em_synchrony if Faraday is defined" do
+      class Faraday
+        class << self
+          attr_reader :default_adapter
+
+          def default_adapter=(adapter)
+            @default_adapter = adapter
           end
+        end
+
+        self.default_adapter = :net_http
+      end
+
+      mock(@em).run_with_error_logging
+      assert_equal :net_http, Faraday.default_adapter
+      @em.run
+      assert_equal :em_synchrony, Faraday.default_adapter
+    end
+  end
+
+  { synchrony: SynchronyProxyMock, run: RunProxyMock }.each do |method, proxy_mock|
+    describe "run" do
+      before do
+        @proxy = ExceptionalSynchrony::EventMachineProxy.new(proxy_mock, nil)
+      end
 
-          def self.run(&block)
-            block.(:run)
+      it "should raise ArgumentError if on_error has invalid value" do
+        assert_raises(ArgumentError, "Invalid on_error: :ignore, must be :log or :raise") do
+          @proxy.run(on_error: :ignore)
+        end
+      end
+
+      describe "without error" do
+        [:log, :raise].each do |on_error|
+          describe "when using #{method} and on_error = #{on_error}" do
+            it "should dispatch to the proxy's synchrony method instead of run iff synchrony" do
+              dispatched = false
+              assert_equal method, (@proxy.run(on_error: on_error) { dispatched = true })
+              assert_equal true, dispatched
+            end
           end
         end
+      end
+
+      describe "with error" do
+        before do
+          set_test_const('ExceptionalSynchrony::EventMachineProxy::WRAP_WITH_ENSURE_COMPLETELY_SAFE', true)
+        end
 
-        mock(proxy_mock).error_handler
+        describe "when using #{method} and on_error = :log" do
+          it "should rescue any exceptions and log them" do
+            mock(ExceptionHandling).log_error(EXCEPTION, "run_with_error_logging", {})
 
-        proxy = ExceptionalSynchrony::EventMachineProxy.new(proxy_mock, nil)
+            @proxy.run(on_error: :log) { raise EXCEPTION }
+          end
+        end
 
-        proxy.run(&@block)
-        expect(@yielded_value).must_equal(synchrony ? :synchrony : :run)
+        describe "when using #{method} and on_error = :raise" do
+          it "should rescue any exceptions and raise FatalRunError" do
+            assert_raises(ExceptionalSynchrony::FatalRunError, "Fatal EventMachine run error") do
+              @proxy.run(on_error: :raise) { raise EXCEPTION }
+            end
+          end
+        end
       end
     end
   end

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: exceptional_synchrony
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.4.0.pre.1
 platform: ruby
 authors:
 - Invoca
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
 date: 2014-01-16 00:00:00.000000000 Z
@@ -88,6 +88,8 @@ extra_rdoc_files: []
 files:
 - ".dependabot/config.yml"
 - ".gitignore"
+- ".jenkins/Jenkinsfile"
+- ".jenkins/ruby_build_pod.yml"
 - ".ruby-gemset"
 - ".ruby-version"
 - CHANGELOG.md
@@ -102,7 +104,6 @@ files:
 - lib/exceptional_synchrony/limited_work_queue.rb
 - lib/exceptional_synchrony/parallel_sync.rb
 - lib/exceptional_synchrony/version.rb
-- semaphore_ci/setup.sh
 - test/test_helper.rb
 - test/unit/callback_exceptions_test.rb
 - test/unit/event_machine_proxy_test.rb
@@ -114,7 +115,7 @@ licenses:
 metadata:
   source_code_uri: https://github.com/Invoca/exceptional_synchrony
   allowed_push_host: https://rubygems.org
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -125,12 +126,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubygems_version: 3.0.3
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Extensions to EventMachine/Synchrony to work well with exceptions
 test_files: []

data/semaphore_ci/setup.sh

@@ -1,3 +0,0 @@
-#!/bin/sh -x
-
-bundle install --path vendor/bundle