rails-threaded-proxy 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2aae2ccc6678cd9afd9e3068a996bfe1d163f0569512a9e37b958c749aeb8096
-  data.tar.gz: 14079d5dfc8a7319c54469d859d2cb5e055ba4fae94d80cebda8cb9968bcd076
+  metadata.gz: 8d77c14092a49dc2e231f233da21a934600a5159aabbc6bbb40294404c8e49d7
+  data.tar.gz: 8590d4359939c617098a036435c340623de538fcb5a65bbd15fe1b72726be86b
 SHA512:
-  metadata.gz: eb6a536989c9b554b79ce943ed143e65a1985b7d535dac729cc7b90f01961eda02325134201e6a027d34775cafde12aa084264cce5a9c59c4c88b9b9a31b147f
-  data.tar.gz: a4c6056afd3971cf18cd9d2ab5e2e3739b0c76a922c655024d1e34f00069b8cbe42f376c1611c040948798b767663e1a0eb7ad7ec6753af90b4e0fc3727808f9
+  metadata.gz: 7704567ef587afce79dbf21ce20f67add2e04c87cbc1efb7fbb3491cc7a95e01e05a8b7881917a64073caca7f4769c07814d22038f06fce045aa80b07f00b501
+  data.tar.gz: 025e8d6eda736b0ffa5c8f8e97d47941f64b06081b4a3a2164c6288a337b50d7325d64971c89fab35622f9c383dad0941584f1e1e4bf80d2a9c99bc4be20501b

data/VERSION

@@ -1 +1 @@
-0.4.0
+0.5.0

data/lib/threaded_proxy/client.rb

@@ -2,10 +2,15 @@
 
 require 'addressable/uri'
 require 'active_support/notifications'
+require 'action_dispatch'
 require 'net/http'
+
 require_relative 'http'
+require_relative 'socket_responder'
 
 module ThreadedProxy
+  class ResponseBodyAlreadyConsumedError < StandardError; end
+
   class Client
     DISALLOWED_RESPONSE_HEADERS = %w[keep-alive].freeze
 
@@ -22,7 +27,6 @@ module ThreadedProxy
     CALLBACK_METHODS = %i[
       on_response
       on_headers
-      on_body
       on_complete
       on_error
     ].freeze
@@ -42,11 +46,13 @@ module ThreadedProxy
     def initialize(origin_url, options = {})
       @origin_url = Addressable::URI.parse(origin_url)
       @options = DEFAULT_OPTIONS.merge(options)
+      @wrote_headers = false
 
       @callbacks = {}
-      CALLBACK_METHODS.each do |method_name|
+      (CALLBACK_METHODS - [:on_error]).each do |method_name|
         @callbacks[method_name] = proc {}
       end
+      @callbacks[:on_error] = proc { |e| raise e }
 
       yield(self) if block_given?
     end
@@ -67,6 +73,8 @@ module ThreadedProxy
         http_request.body = @options[:body]
       end
 
+      socket_responder = SocketResponder.new(socket)
+
       ActiveSupport::Notifications.instrument('threaded_proxy.fetch', method: request_method, url: @origin_url.to_s,
                                                                       headers: request_headers) do
         http = HTTP.new(@origin_url.host, @origin_url.port || default_port(@origin_url))
@@ -76,15 +84,14 @@ module ThreadedProxy
 
         http.start do
           http.request(http_request) do |client_response|
-            @callbacks[:on_response].call(client_response, socket)
+            @callbacks[:on_response].call(client_response, socket_responder)
             break if socket.closed?
 
             log('Writing response status and headers')
             write_headers(client_response, socket)
             break if socket.closed?
 
-            @callbacks[:on_body].call(client_response, socket)
-            break if socket.closed?
+            raise ResponseBodyAlreadyConsumedError if client_response.read?
 
             # There may have been some existing data in client_response's read buffer, flush it out
             # before we manually connect the raw sockets
@@ -97,9 +104,13 @@ module ThreadedProxy
 
             @callbacks[:on_complete].call(client_response)
           end
-        rescue StandardError => e
-          @callbacks[:on_error].call(e) or raise
         end
+      rescue StandardError => e
+        @callbacks[:on_error].call(e, socket_responder)
+        # Default to 500 if the error callback didn't write a response
+        socket_responder.render(status: 500, text: 'Internal Server Error') unless socket.closed? || @wrote_headers
+
+        socket.close unless socket.closed?
       end
     end
 
@@ -118,6 +129,7 @@ module ThreadedProxy
 
       # Done with headers
       socket.write "\r\n"
+      @wrote_headers = true
     end
 
     def default_port(uri)

data/lib/threaded_proxy/controller.rb

@@ -4,36 +4,58 @@ require_relative 'client'
 
 module ThreadedProxy
   module Controller
+    # Proxies a fetch request to the specified origin URL, allowing for hijacking
+    # the controller response outside of the Rack request/response cycle.
+    #
+    # @param origin_url [String] The URL to which the request will be proxied.
+    # @param options [Hash] Optional parameters for the request.
+    # @option options [Symbol] :body The body of the request. If set to :rack, the request body stream will be used.
+    # @option options [Hash] :headers Additional headers to include in the request.
+    # @yield [Client] Optional block to configure the client.
+    #
+    # @raise [RuntimeError] If a non-chunked POST request is made without a content-length header.
+    #
+    # @return [void]
+    #
+    # @example
+    #   proxy_fetch('http://example.com', body: :rack, headers: { 'Custom-Header' => 'value' }) do |client|
+    #     client.on_headers { |client_response| client_response['x-foo'] = 'bar' }
+    #     client.on_error { |e| Rails.logger.error(e) }
+    #   end
     def proxy_fetch(origin_url, options = {}, &block)
       # hijack the response so we can take it outside of the rack request/response cycle
       request.env['rack.hijack'].call
       socket = request.env['rack.hijack_io']
 
-      Thread.new do
-        if options[:body] == :rack
-          options[:headers] ||= {}
-          options[:body] = request.body_stream
-
-          if request.env['HTTP_TRANSFER_ENCODING'] == 'chunked'
-            options[:headers]['Transfer-Encoding'] = 'chunked'
-          elsif request.env['CONTENT_LENGTH']
-            options[:headers]['content-length'] = request.env['CONTENT_LENGTH'].to_s
-          else
-            raise 'Cannot proxy a non-chunked POST request without content-length'
-          end
-
-          options[:headers]['Content-Type'] = request.env['CONTENT_TYPE'] if request.env['CONTENT_TYPE']
-        end
+      options.deep_merge!(proxy_options_from_request) if options[:body] == :rack
 
+      Thread.new do
         client = Client.new(origin_url, options, &block)
         client.start(socket)
-      rescue Errno::EPIPE
-        # client disconnected before request finished; not an error
       ensure
         socket.close unless socket.closed?
       end
 
       head :ok
     end
+
+    protected
+
+    def proxy_options_from_request
+      options = {}
+      options[:headers] ||= {}
+      options[:body] = request.body_stream
+
+      if request.env['HTTP_TRANSFER_ENCODING'] == 'chunked'
+        options[:headers]['Transfer-Encoding'] = 'chunked'
+      elsif request.env['CONTENT_LENGTH']
+        options[:headers]['content-length'] = request.env['CONTENT_LENGTH'].to_s
+      else
+        raise 'Cannot proxy a non-chunked POST request without content-length'
+      end
+
+      options[:headers]['Content-Type'] = request.env['CONTENT_TYPE'] if request.env['CONTENT_TYPE']
+      options
+    end
   end
 end

data/lib/threaded_proxy/http.rb

@@ -20,7 +20,14 @@ module ThreadedProxy
 
     def request(*args)
       if block_given?
-        super { |res| yield hijack_response(res) }
+        super do |res|
+          access_read(res)
+          yield(res).tap do
+            # In the block case, the response is hijacked _after_ the block is called
+            # to allow the block to read the response body if it wants
+            hijack_response(res)
+          end
+        end
       else
         hijack_response(super)
       end
@@ -30,8 +37,19 @@ module ThreadedProxy
 
     # We read the response ourselves; don't need net/http to try to read it again
     def hijack_response(res)
-      res.instance_variable_set('@read', true)
+      access_read(res) unless res.respond_to?(:read?)
+      res.read = true
       res
     end
+
+    def access_read(res)
+      res.singleton_class.class_eval do
+        attr_writer :read
+
+        def read?
+          @read
+        end
+      end
+    end
   end
 end

data/lib/threaded_proxy/socket_responder.rb

@@ -0,0 +1,65 @@
+module ThreadedProxy
+  class SocketResponder
+    def initialize(socket)
+      @socket = socket
+    end
+
+    def render(options = {})
+      return false if @socket.closed?
+
+      status  = options[:status] || 200
+      headers = options[:headers] || {}
+      body    = options[:body]
+      json    = options[:json]
+      text    = options[:text]
+
+      if json
+        body = json.to_json
+        headers['Content-Type'] ||= 'application/json; charset=utf-8'
+      elsif text
+        body = text
+        headers['Content-Type'] ||= 'text/plain; charset=utf-8'
+      else
+        body ||= ''
+      end
+
+      response = ActionDispatch::Response.new(status, headers, [])
+      response.prepare!
+
+      # Build the HTTP response
+      response_str = "HTTP/1.1 #{response.status} #{response.message}\r\n"
+      response.headers.each do |key, value|
+        Array(value).each do |v|
+          response_str += "#{key}: #{v}\r\n"
+        end
+      end
+      response_str += "\r\n"
+
+      write(response_str)
+
+      if body.respond_to?(:read)
+        IO.copy_stream(body, @socket)
+      else
+        write(body)
+      end
+
+      close
+    end
+
+    def redirect_to(url)
+      render(status: 302, headers: { 'Location' => url })
+    end
+
+    def write(data)
+      @socket.write(data) unless @socket.closed?
+    end
+
+    def close
+      @socket.close unless @socket.closed?
+    end
+
+    def closed?
+      @socket.closed?
+    end
+  end
+end

data/rails-threaded-proxy.gemspec

@@ -2,19 +2,18 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: rails-threaded-proxy 0.4.0 ruby lib
+# stub: rails-threaded-proxy 0.5.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "rails-threaded-proxy".freeze
-  s.version = "0.4.0".freeze
+  s.version = "0.5.0".freeze
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Michael Nutt".freeze]
-  s.date = "2024-10-15"
+  s.date = "2024-10-18"
   s.description = "Threaded reverse proxy for Ruby on Rails".freeze
   s.email = "michael@nuttnet.net".freeze
-  s.executables = ["bundle".freeze, "htmldiff".freeze, "jeweler".freeze, "ldiff".freeze, "nokogiri".freeze, "racc".freeze, "rackup".freeze, "rake".freeze, "rdoc".freeze, "ri".freeze, "rspec".freeze, "rubocop".freeze, "semver".freeze]
   s.extra_rdoc_files = [
     "LICENSE",
     "README.md"
@@ -30,28 +29,17 @@ Gem::Specification.new do |s|
     "README.md",
     "Rakefile",
     "VERSION",
-    "bin/bundle",
-    "bin/htmldiff",
-    "bin/jeweler",
-    "bin/ldiff",
-    "bin/nokogiri",
-    "bin/racc",
-    "bin/rackup",
-    "bin/rake",
-    "bin/rdoc",
-    "bin/ri",
-    "bin/rspec",
-    "bin/rubocop",
-    "bin/semver",
     "lib/rails-threaded-proxy.rb",
     "lib/threaded-proxy.rb",
     "lib/threaded_proxy.rb",
     "lib/threaded_proxy/client.rb",
     "lib/threaded_proxy/controller.rb",
     "lib/threaded_proxy/http.rb",
+    "lib/threaded_proxy/socket_responder.rb",
     "rails-threaded-proxy.gemspec",
     "spec/spec_helper.rb",
-    "spec/threaded_proxy/client_spec.rb"
+    "spec/threaded_proxy/client_spec.rb",
+    "spec/threaded_proxy/controller_spec.rb"
   ]
   s.homepage = "http://github.com/mnutt/rails-threaded-proxy".freeze
   s.licenses = ["MIT".freeze]

data/spec/threaded_proxy/client_spec.rb

@@ -5,6 +5,15 @@ require 'json'
 
 BACKEND_STUB_PORT = 38_293
 
+def parse_raw_response(raw_response)
+  status, rest = raw_response.split("\r\n", 2)
+  headers, body = rest.split("\r\n\r\n", 2)
+
+  parsed_headers = headers.split("\r\n").map { |h| h.split(': ', 2) }.to_h
+
+  [status, parsed_headers, body]
+end
+
 RSpec.describe ThreadedProxy::Client do
   before(:all) do
     @backend_server = WEBrick::HTTPServer.new(Port: BACKEND_STUB_PORT,
@@ -50,15 +59,199 @@ RSpec.describe ThreadedProxy::Client do
                                        body: 'hello world')
     client.start(socket)
 
-    status, rest = socket.string.split("\r\n", 2)
-    headers, body = rest.split("\r\n\r\n", 2)
+    status, headers, body = parse_raw_response(socket.string)
 
     parsed_body = JSON.parse(body)
-    parsed_headers = headers.split("\r\n").map { |h| h.split(': ', 2) }.to_h
 
     expect(status).to eq('HTTP/1.1 200 OK')
-    expect(parsed_headers['content-type']).to eq('application/json')
+    expect(headers['content-type']).to eq('application/json')
     expect(parsed_body['path']).to eq('/post')
     expect(parsed_body['headers']['content-length']).to eq(['11'])
   end
+
+  describe 'callbacks' do
+    describe 'on_headers' do
+      it 'proxies a request and modifies the response headers' do
+        socket = StringIO.new
+
+        client = ThreadedProxy::Client.new("http://localhost:#{BACKEND_STUB_PORT}/get") do |config|
+          config.on_headers do |response|
+            response['X-Test'] = 'test'
+          end
+        end
+        client.start(socket)
+
+        status, headers, body = parse_raw_response(socket.string)
+
+        expect(status).to eq('HTTP/1.1 200 OK')
+        expect(headers['x-test']).to eq('test')
+        expect(headers['connection']).to eq('close')
+        expect(body).to eq('Received request: /get')
+      end
+    end
+
+    describe 'on_complete' do
+      it 'fires when the request is successful' do
+        socket = StringIO.new
+        received_client_response = nil
+
+        client = ThreadedProxy::Client.new("http://localhost:#{BACKEND_STUB_PORT}/get") do |config|
+          config.on_complete do |client_response|
+            received_client_response = client_response
+          end
+        end
+        client.start(socket)
+
+        expect(received_client_response.code).to eq('200')
+      end
+    end
+
+    describe 'on_error' do
+      it 'fires when the request is unsuccessful' do
+        socket = StringIO.new
+        received_error = nil
+
+        client = ThreadedProxy::Client.new('http://localhost:9999') do |config|
+          config.on_error do |e|
+            received_error = e
+          end
+        end
+        client.start(socket)
+
+        expect(received_error).to be_a_kind_of(Errno::ECONNREFUSED)
+
+        status, headers, body = parse_raw_response(socket.string)
+        expect(status).to eq('HTTP/1.1 500 Internal Server Error')
+        expect(headers['Content-Type']).to eq('text/plain; charset=utf-8')
+        expect(body).to eq('Internal Server Error')
+      end
+
+      it 'returns custom response on error' do
+        socket = StringIO.new
+        received_error = nil
+
+        client = ThreadedProxy::Client.new('http://localhost:9999') do |config|
+          config.on_error do |e, response|
+            response.render status: 404, text: 'Custom error'
+            received_error = e
+          end
+        end
+        client.start(socket)
+
+        status, headers, body = parse_raw_response(socket.string)
+        expect(status).to eq('HTTP/1.1 404 Not Found')
+        expect(headers['Content-Type']).to eq('text/plain; charset=utf-8')
+        expect(body).to eq('Custom error')
+        expect(received_error).to be_a_kind_of(Errno::ECONNREFUSED)
+      end
+    end
+
+    describe 'on_response' do
+      it 'proxies a request and lets caller send response' do
+        socket = StringIO.new
+
+        client = ThreadedProxy::Client.new("http://localhost:#{BACKEND_STUB_PORT}/get") do |config|
+          config.on_response do |client_response, response|
+            response.render status: 200, json: { body: client_response.body }, headers: { 'x-passed': 'yes' }
+          end
+        end
+        client.start(socket)
+
+        status, headers, body = parse_raw_response(socket.string)
+
+        parsed_body = JSON.parse(body)
+
+        expect(status).to eq('HTTP/1.1 200 OK')
+        expect(headers['Content-Type']).to eq('application/json; charset=utf-8')
+        expect(headers['x-passed']).to eq('yes')
+        expect(parsed_body['body']).to eq('Received request: /get')
+      end
+
+      it 'accepts IO objects as the body' do
+        socket = StringIO.new
+
+        client = ThreadedProxy::Client.new("http://localhost:#{BACKEND_STUB_PORT}/get") do |config|
+          config.on_response do |_client_response, response|
+            response.render status: 200, body: StringIO.new('this is IO')
+          end
+        end
+        client.start(socket)
+
+        status, _headers, body = parse_raw_response(socket.string)
+        expect(status).to eq('HTTP/1.1 200 OK')
+        expect(body).to eq('this is IO')
+      end
+
+      it 'accepts json body' do
+        socket = StringIO.new
+
+        client = ThreadedProxy::Client.new("http://localhost:#{BACKEND_STUB_PORT}/get") do |config|
+          config.on_response do |_client_response, response|
+            response.render status: 200, json: { key: 'value' }
+          end
+        end
+        client.start(socket)
+
+        status, headers, body = parse_raw_response(socket.string)
+
+        parsed_body = JSON.parse(body)
+
+        expect(status).to eq('HTTP/1.1 200 OK')
+        expect(headers['Content-Type']).to eq('application/json; charset=utf-8')
+        expect(parsed_body['key']).to eq('value')
+      end
+
+      it 'redirects to a URL' do
+        socket = StringIO.new
+
+        client = ThreadedProxy::Client.new("http://localhost:#{BACKEND_STUB_PORT}/get") do |config|
+          config.on_response do |_client_response, response|
+            response.redirect_to('http://example.com')
+          end
+        end
+        client.start(socket)
+
+        status, headers, _body = parse_raw_response(socket.string)
+
+        expect(status).to eq('HTTP/1.1 302 Found')
+        expect(headers['Location']).to eq('http://example.com')
+      end
+
+      it 'handles errors in on_response' do
+        socket = StringIO.new
+        received_error = nil
+
+        client = ThreadedProxy::Client.new("http://localhost:#{BACKEND_STUB_PORT}/get") do |config|
+          config.on_response do |_client_response, _response|
+            raise 'error in on_response'
+          end
+
+          config.on_error do |e|
+            received_error = e
+          end
+        end
+
+        client.start(socket)
+
+        status, headers, body = parse_raw_response(socket.string)
+
+        expect(status).to eq('HTTP/1.1 500 Internal Server Error')
+        expect(headers['Content-Type']).to eq('text/plain; charset=utf-8')
+        expect(body).to eq('Internal Server Error')
+        expect(received_error.message).to eq('error in on_response')
+      end
+
+      it 'errors if on_response reads the body but does not render a response' do
+        socket = StringIO.new
+
+        client = ThreadedProxy::Client.new("http://localhost:#{BACKEND_STUB_PORT}/get") do |config|
+          config.on_response do |client_response, _response|
+            client_response.body
+          end
+        end
+
+        expect { client.start(socket) }.to raise_error(ThreadedProxy::ResponseBodyAlreadyConsumedError)
+      end
+    end
+  end
 end

data/spec/threaded_proxy/controller_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'rails-threaded-proxy'
+
+class TestController
+  include ThreadedProxy::Controller
+
+  attr_accessor :request
+end
+
+RSpec.describe ThreadedProxy::Controller do
+  let(:request) { double(env: {}) }
+  let(:controller) do
+    TestController.new.tap do |controller|
+      controller.request = request
+    end
+  end
+
+  describe '#proxy_options_from_request' do
+    subject { controller.send(:proxy_options_from_request) }
+    let(:body_stream) { StringIO.new('HELLO') }
+
+    describe 'when the request is chunked' do
+      let(:request) { double(body_stream:, env: { 'HTTP_TRANSFER_ENCODING' => 'chunked' }) }
+
+      it 'sets the Transfer-Encoding header' do
+        expect(subject).to include(headers: { 'Transfer-Encoding' => 'chunked' },
+                                   body: body_stream)
+      end
+    end
+
+    describe 'when the request is not chunked' do
+      let(:request) { double(body_stream:, env: { 'CONTENT_LENGTH' => '5', 'CONTENT_TYPE' => 'application/json' }) }
+
+      it 'sets the Content-Length header' do
+        expect(subject).to include(headers: { 'content-length' => '5',
+                                              'Content-Type' => 'application/json' },
+                                   body: body_stream)
+      end
+    end
+
+    describe 'when the request is not chunked and has no content-length' do
+      let(:request) { double(body_stream:, env: {}) }
+
+      it 'raises an error' do
+        expect { subject }.to raise_error('Cannot proxy a non-chunked POST request without content-length')
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-threaded-proxy
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Michael Nutt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-15 00:00:00.000000000 Z
+date: 2024-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -138,20 +138,7 @@ dependencies:
         version: '0'
 description: Threaded reverse proxy for Ruby on Rails
 email: michael@nuttnet.net
-executables:
-- bundle
-- htmldiff
-- jeweler
-- ldiff
-- nokogiri
-- racc
-- rackup
-- rake
-- rdoc
-- ri
-- rspec
-- rubocop
-- semver
+executables: []
 extensions: []
 extra_rdoc_files:
 - LICENSE
@@ -167,28 +154,17 @@ files:
 - README.md
 - Rakefile
 - VERSION
-- bin/bundle
-- bin/htmldiff
-- bin/jeweler
-- bin/ldiff
-- bin/nokogiri
-- bin/racc
-- bin/rackup
-- bin/rake
-- bin/rdoc
-- bin/ri
-- bin/rspec
-- bin/rubocop
-- bin/semver
 - lib/rails-threaded-proxy.rb
 - lib/threaded-proxy.rb
 - lib/threaded_proxy.rb
 - lib/threaded_proxy/client.rb
 - lib/threaded_proxy/controller.rb
 - lib/threaded_proxy/http.rb
+- lib/threaded_proxy/socket_responder.rb
 - rails-threaded-proxy.gemspec
 - spec/spec_helper.rb
 - spec/threaded_proxy/client_spec.rb
+- spec/threaded_proxy/controller_spec.rb
 homepage: http://github.com/mnutt/rails-threaded-proxy
 licenses:
 - MIT

data/bin/bundle

@@ -1,109 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# This file was generated by Bundler.
-#
-# The application 'bundle' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-require "rubygems"
-
-m = Module.new do
-  module_function
-
-  def invoked_as_script?
-    File.expand_path($0) == File.expand_path(__FILE__)
-  end
-
-  def env_var_version
-    ENV["BUNDLER_VERSION"]
-  end
-
-  def cli_arg_version
-    return unless invoked_as_script? # don't want to hijack other binstubs
-    return unless "update".start_with?(ARGV.first || " ") # must be running `bundle update`
-    bundler_version = nil
-    update_index = nil
-    ARGV.each_with_index do |a, i|
-      if update_index && update_index.succ == i && a.match?(Gem::Version::ANCHORED_VERSION_PATTERN)
-        bundler_version = a
-      end
-      next unless a =~ /\A--bundler(?:[= ](#{Gem::Version::VERSION_PATTERN}))?\z/
-      bundler_version = $1
-      update_index = i
-    end
-    bundler_version
-  end
-
-  def gemfile
-    gemfile = ENV["BUNDLE_GEMFILE"]
-    return gemfile if gemfile && !gemfile.empty?
-
-    File.expand_path("../Gemfile", __dir__)
-  end
-
-  def lockfile
-    lockfile =
-      case File.basename(gemfile)
-      when "gems.rb" then gemfile.sub(/\.rb$/, ".locked")
-      else "#{gemfile}.lock"
-      end
-    File.expand_path(lockfile)
-  end
-
-  def lockfile_version
-    return unless File.file?(lockfile)
-    lockfile_contents = File.read(lockfile)
-    return unless lockfile_contents =~ /\n\nBUNDLED WITH\n\s{2,}(#{Gem::Version::VERSION_PATTERN})\n/
-    Regexp.last_match(1)
-  end
-
-  def bundler_requirement
-    @bundler_requirement ||=
-      env_var_version ||
-      cli_arg_version ||
-      bundler_requirement_for(lockfile_version)
-  end
-
-  def bundler_requirement_for(version)
-    return "#{Gem::Requirement.default}.a" unless version
-
-    bundler_gem_version = Gem::Version.new(version)
-
-    bundler_gem_version.approximate_recommendation
-  end
-
-  def load_bundler!
-    ENV["BUNDLE_GEMFILE"] ||= gemfile
-
-    activate_bundler
-  end
-
-  def activate_bundler
-    gem_error = activation_error_handling do
-      gem "bundler", bundler_requirement
-    end
-    return if gem_error.nil?
-    require_error = activation_error_handling do
-      require "bundler/version"
-    end
-    return if require_error.nil? && Gem::Requirement.new(bundler_requirement).satisfied_by?(Gem::Version.new(Bundler::VERSION))
-    warn "Activating bundler (#{bundler_requirement}) failed:\n#{gem_error.message}\n\nTo install the version of bundler this project requires, run `gem install bundler -v '#{bundler_requirement}'`"
-    exit 42
-  end
-
-  def activation_error_handling
-    yield
-    nil
-  rescue StandardError, LoadError => e
-    e
-  end
-end
-
-m.load_bundler!
-
-if m.invoked_as_script?
-  load Gem.bin_path("bundler", "bundle")
-end

data/bin/htmldiff

@@ -1,27 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# This file was generated by Bundler.
-#
-# The application 'htmldiff' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
-
-bundle_binstub = File.expand_path("bundle", __dir__)
-
-if File.file?(bundle_binstub)
-  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
-    load(bundle_binstub)
-  else
-    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
-Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
-  end
-end
-
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("diff-lcs", "htmldiff")

data/bin/jeweler

@@ -1,27 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# This file was generated by Bundler.
-#
-# The application 'jeweler' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
-
-bundle_binstub = File.expand_path("bundle", __dir__)
-
-if File.file?(bundle_binstub)
-  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
-    load(bundle_binstub)
-  else
-    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
-Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
-  end
-end
-
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("jeweler", "jeweler")

data/bin/ldiff

@@ -1,27 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# This file was generated by Bundler.
-#
-# The application 'ldiff' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
-
-bundle_binstub = File.expand_path("bundle", __dir__)
-
-if File.file?(bundle_binstub)
-  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
-    load(bundle_binstub)
-  else
-    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
-Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
-  end
-end
-
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("diff-lcs", "ldiff")

data/bin/nokogiri

@@ -1,27 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# This file was generated by Bundler.
-#
-# The application 'nokogiri' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
-
-bundle_binstub = File.expand_path("bundle", __dir__)
-
-if File.file?(bundle_binstub)
-  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
-    load(bundle_binstub)
-  else
-    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
-Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
-  end
-end
-
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("nokogiri", "nokogiri")

data/bin/racc

@@ -1,27 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# This file was generated by Bundler.
-#
-# The application 'racc' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
-
-bundle_binstub = File.expand_path("bundle", __dir__)
-
-if File.file?(bundle_binstub)
-  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
-    load(bundle_binstub)
-  else
-    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
-Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
-  end
-end
-
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("racc", "racc")

data/bin/rackup

@@ -1,27 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# This file was generated by Bundler.
-#
-# The application 'rackup' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
-
-bundle_binstub = File.expand_path("bundle", __dir__)
-
-if File.file?(bundle_binstub)
-  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
-    load(bundle_binstub)
-  else
-    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
-Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
-  end
-end
-
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("rack", "rackup")

data/bin/rake

@@ -1,27 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# This file was generated by Bundler.
-#
-# The application 'rake' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
-
-bundle_binstub = File.expand_path("bundle", __dir__)
-
-if File.file?(bundle_binstub)
-  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
-    load(bundle_binstub)
-  else
-    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
-Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
-  end
-end
-
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("rake", "rake")

data/bin/rdoc

@@ -1,27 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# This file was generated by Bundler.
-#
-# The application 'rdoc' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
-
-bundle_binstub = File.expand_path("bundle", __dir__)
-
-if File.file?(bundle_binstub)
-  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
-    load(bundle_binstub)
-  else
-    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
-Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
-  end
-end
-
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("rdoc", "rdoc")

data/bin/ri

@@ -1,27 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# This file was generated by Bundler.
-#
-# The application 'ri' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
-
-bundle_binstub = File.expand_path("bundle", __dir__)
-
-if File.file?(bundle_binstub)
-  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
-    load(bundle_binstub)
-  else
-    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
-Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
-  end
-end
-
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("rdoc", "ri")

data/bin/rspec

@@ -1,27 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# This file was generated by Bundler.
-#
-# The application 'rspec' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
-
-bundle_binstub = File.expand_path("bundle", __dir__)
-
-if File.file?(bundle_binstub)
-  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
-    load(bundle_binstub)
-  else
-    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
-Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
-  end
-end
-
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("rspec-core", "rspec")

data/bin/rubocop

@@ -1,27 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# This file was generated by Bundler.
-#
-# The application 'rubocop' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
-
-bundle_binstub = File.expand_path('bundle', __dir__)
-
-if File.file?(bundle_binstub)
-  if File.read(bundle_binstub, 300).include?('This file was generated by Bundler')
-    load(bundle_binstub)
-  else
-    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
-Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
-  end
-end
-
-require 'rubygems'
-require 'bundler/setup'
-
-load Gem.bin_path('rubocop', 'rubocop')

data/bin/semver

@@ -1,27 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# This file was generated by Bundler.
-#
-# The application 'semver' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
-
-bundle_binstub = File.expand_path("bundle", __dir__)
-
-if File.file?(bundle_binstub)
-  if File.read(bundle_binstub, 300).include?("This file was generated by Bundler")
-    load(bundle_binstub)
-  else
-    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
-Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
-  end
-end
-
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("semver2", "semver")