by 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '078f15faf5964b6b3bb4ac860c7733e069c0a8cb46556e9af7e555f8c3808d54'
+  data.tar.gz: e878d37b2417d4d655f138d3e2bae5bf51a76c34b7a3fab2956bc40c88a77dbb
+SHA512:
+  metadata.gz: 128a3c27c4dfe729b62fa15d9b961f7384a75ec02030403ae85b376981b731c8d892305732e519cbfb84ab105b816275e6a910afff7f9187c2f723d7683eb12d
+  data.tar.gz: 61895959cd9a6097ded3430017d0a831affa73c668c8301579dd4a62f661a6c1fd3bb09871d5eb321ce9d97fb7a64c573fc8b92a60ae34b7adfcad835eb0ae08

data/CHANGELOG

@@ -0,0 +1,3 @@
+=== 1.0.0 (2023-02-07)
+
+* Initial Public Release

data/MIT-LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2023 Jeremy Evans
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+  
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+   
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,284 @@
+= by
+
+by is a library preloader for Ruby designed to speed up process startup.
+It uses a client/server approach, where the server loads the libraries and
+listens on a UNIX socket, and the client connects to that socket to run
+a process.  For each client connection, the server forks a worker process,
+which uses the current directory, stdin, stdout, stderr, and environment
+of the client process.  The worker process then processes the arguments
+provided by the client. The client process waits until the worker process
+returns an exit code and closes the socket, and uses exit code 0 (normal
+exit) if the worker process indicates success, or exit code 1 (error)
+if the worker process indicates an error.
+
+== Installation
+
+  gem install by
+
+== Source Code
+
+Source code is available on GitHub at https://github.com/jeremyevans/by
+
+== Usage
+
+To use +by+, you first start <tt>by-server</tt>, passing in libraries you would
+like to preload.
+
+  $ by-server sequel roda capybara
+
+Then you can run ruby with the libraries preloaded using +by+:
+
+  $ by -e 'p [Sequel, Roda, Capybara]'
+  [Sequel, Roda, Capybara]
+
+The advantage of using +by+ is that the libraries are already loaded,
+so Ruby doesn't have to find the libraries and parse the files in each
+library on process startup.  Here's a performance comparison:
+
+  $ /usr/bin/time ruby -e 'require "sequel"; require "roda"; require "capybara"'
+          1.67 real         0.93 user         0.66 sys
+
+  $ /usr/bin/time   by -e 'require "sequel"; require "roda"; require "capybara"'
+          0.37 real         0.20 user         0.15 sys
+
+The more libraries your program uses that you can preload in the server
+program, the greater the speedup this offers.
+
+== Speeding Things Up Even More By Avoiding Rubygems
+
+Loading Rubygems is by far the slowest thing that Ruby does during
+process initialization:
+
+  $ /usr/bin/time ruby -e ''
+          0.25 real         0.11 user         0.14 sys
+
+  $ /usr/bin/time ruby --disable-gems -e ''
+          0.03 real         0.02 user         0.01 sys
+
+You can speedup +by+ by making it not require rubygems, since it only
+needs the +socket+ standard library. The only issue with that is that
++by+ is distributed as a gem.  There are a few workarounds.
+
+1. Create a shell alias.  How you create the alias will depend on
+   the shell you are using, but here's some Ruby code that will
+   output an alias command that will work for most shells:
+
+     require 'rbconfig'
+     by = Gem.activate_bin_path("by", "by")
+     ruby = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['RUBY_INSTALL_NAME'])
+     puts "alias by='#{ruby} --disable-gems #{by}'"
+
+   Note that one issue with using a shell alias is that it only
+   works when loaded and used by the shell, it won't work if
+   executed by another program.
+
+2. Copy the +by+ program and modify the shebang line to use the
+   path to your +ruby+ binary and <tt>--disable-gems</tt>.  You can
+   get the path to the +by+ program with the following Ruby code.
+
+     puts Gem.activate_bin_path("by", "by")
+
+   You would copy that file to somewhere in your <tt>$PATH</tt>
+   before where the rubygems wrapper is installed, and then modify
+   the shebang.
+
+3. Add your own shell wrapper program that calls +by+. Here's some
+   example Ruby code that may work, though whether it does depends
+   on your shell.
+
+     require 'rbconfig'
+     by = Gem.activate_bin_path("by", "by")
+     ruby = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['RUBY_INSTALL_NAME'])
+     File.binwrite("by", "#!/bin/sh\nexec #{ruby} --disable-gems #{by} \"$@\"\n")
+     File.chmod(0755, "by")
+
+With each of these approaches, you can get much faster program
+execution:
+
+  $ /usr/bin/time ./by -e 'require "sequel"; require "roda"; require "capybara"'
+          0.08 real         0.05 user         0.03 sys
+
+As you can see, by avoiding Rubygems, using +by+ to require the
+three libraries executes three times faster than Ruby itself starts
+if you are using Rubygems.
+
+With each of these approaches, you need to update the alias/wrapper
+any time you update the +by+ gem when the +by+ program itself has
+changed.  However, the +by+ program itself is quite small and simple
+and unlikely to change.
+
+== Argument Handling
+
+<tt>by-server</tt> treats all arguments provided on the command line as
+arguments to <tt>Kernel#require</tt>.
+
++by+ passes all arguments to the worker process over the UNIX socket.
+
+The worker process handles arguments passed by the client in the following
+way:
+
+* If first argument is +m+ or matches <tt>/\.rb:\d+\z</tt>, uses the +m+
+  gem to run a single minitest test by line number, waiting until after
+  the test is run so that it can return the correct exit code.
+* If first argument is +irb+, starts an IRB shell with remaining arguments
+  in ARGV.
+* If first argument is <tt>-e</tt>, evaluates second argument as Ruby code,
+  with remaining arguments in ARGV.
+* If no arguments are given, evaluates Ruby code provided on stdin.
+* Otherwise, treats first argument as a file name, expands the file path,
+  and then requires that.  If Minitest is loaded and set to autorun, waits
+  until after Minitest runs tests, so it can return the correct exit code.
+  If Minitest is not loaded or not set to autorun, exits after the file
+  is required.
+
+=== Restarting the Server
+
+If <tt>by-server</tt> is already running, running <tt>by-server</tt> will
+shutdown the existing server and start a new server with the arguments it
+is given.
+
+=== Stopping the Server
+
+Running <tt>by-server stop</tt> will stop an existing server without starting
+a new server.  If no server is running, <tt>by-server stop</tt> will exit
+without doing anything.
+
+You can also send a +TERM+ signal to the <tt>by-server</tt> process to shut
+the server down gracefully.  Be aware that by default, <tt>by-server</tt>
+daemonizes, so the pid of the started <tt>by-server</tt> will not be the
+pid <tt>by-server</tt> uses to run.  For that reason, it is recommended to
+use <tt>by-server stop</tt> to stop the server.
+
+=== Running Multiple Servers
+
+==== Manually
+
+You can run multiple +by-server+ processes concurrently by making sure
+they each use a separate UNIX socket, which you can configure with the
++BY_SOCKET+ environment variable:
+
+  $ BY_SOCKET=~/.by_sequel_socket by-server sequel
+  $ BY_SOCKET=~/.by_roda_socket by-server roda
+  $ BY_SOCKET=~/.by_sequel_socket by -e 'p [defined?(Sequel), defined?(Roda)]'
+  ["constant", nil]
+  $ BY_SOCKET=~/.by_roda_socket by -e 'p [defined?(Sequel), defined?(Roda)]'
+  [nil, "constant"]
+
+==== Using <tt>by-session</tt>
+
+In many cases, it can be helpful to have a separate server process for
+each application directory. <tt>by-session</tt> exists to make this easier.
+<tt>by-session</tt> will call <tt>by-server</tt> with the arguments it is
+given, using a socket in the current directory by default, and then open a
+new shell.  When the shell exits, <tt>by-session</tt> will stop the
+<tt>by-server</tt> it spawned.
+
+If the directory in which you are running <tt>by-session</tt> has a +Gemfile+,
+you could add a file named <tt>.by-session-setup.rb</tt> in your home directory,
+which contains:
+
+  require 'bundler/setup'
+  Bundler.require(:default)
+
+When you to startup a <tt>by-session</tt> shell for the directory using the
++Gemfile+, you can use:
+
+  $ by-session ~/.by-session-setup
+
+This will load all gems in the +Gemfile+ into the <tt>by-server</tt> process.
+If you are doing this, you must be careful to only run this in a directory
+that you trust.
+
+If you don't want to specify the <tt>~/.by-session-setup</tt> argument every
+time you start <tt>by-session</tt>, you can use the +BY_SERVER_AUTO_REQUIRE+
+environment variable.
+
+=== Environment Variables
+
++BY_SOCKET+ :: The path to the UNIX socket to listen on (<tt>by-server</tt>)
+               or connect to (+by+). 
++DEBUG+ :: If set to +log+, logs <tt>$LOADED_FEATURES</tt> to stdout
+           after requiring libraries (<tt>by-server</tt>) or before worker
+           process shutdown (+by+).
+
+==== <tt>by-server</tt>-Specific Environment Variables
+
++BY_SERVER_AUTO_REQUIRE+ :: Whitespace separated list of libraries for
+                            <tt>by-server</tt> to require, before it requires
+                            command line arguments.
++BY_SERVER_NO_DAEMON+ :: Do not daemonize if set.
++BY_SERVER_DAEMON_NO_CHDIR+ :: Do not change directory to <tt>/</tt>
+                               when daemonizing if set.
++BY_SERVER_DAEMON_NO_REDIR_STDIO+ :: Do not redirect stdio to
+                                     <tt>/dev/null</tt> when daemonizing
+                                     if set.
+
+== <tt>by-server</tt> Signals
+
++QUIT+ :: Close the socket (this is what <tt>by-server stop</tt> uses).
++TERM+ :: Delete the socket path and then close the socket.
+
+== Internals
+
+There are two classes, <tt>By::Server</tt> and <tt>By::Worker</tt>.
+<tt>By::Server</tt> listens on the UNIX socket, forking worker
+processes for each connection. <tt>By::Worker</tt> is run in each
+worker process handling receiving data from the +by+ command line
+program.
+
+The +by+ command line program is self-contained, there is no
+Ruby class for the behavior, to make sure startup is as fast as
+possible. <tt>by-session</tt> is also self-contained.
+
+== Customization
+
+For custom handling of arguments, you can require <tt>by/server</tt>
+and use the <tt>By::Server.with_argument_handler</tt> method. For example,
+if you wanted to add support for an initial <tt>-I</tt> option to modify
+the load path, and then use the standard argument handling:
+
+  require 'by/server'
+
+  By::Server.with_argument_handler do |args|
+    if args[0] == '-I'
+      args.shift
+      $LOAD_PATH.unshift(args.shift)
+    end
+    super(args)
+  end.new.run
+
+Note that if you do this, you are responsible for making sure
+to correctly communicate with the client socket.  Otherwise, it's
+possible the client socket may hang waiting on a response. Please
+review the default argument handling in <tt>lib/by/worker.rb</tt>
+before writing your own argument handler.
+
+== Security
+
+As with any program that forks without executing, the memory layout
+is shared by the client and the server program, which can lead to
+Blind Return Oriented Programming (BROP) attacks.  You should avoid
+using +by+ to run a program that deals with any untrusted input.
++by+ makes a deliberate choice to trade security to make process
+startup as fast as possible.
+
+The server socket is set to mode 0600, so it is only readable and
+writable by the same user.
+
+== Name
+
+The name +by+ was chosen because it is +ruby+ with the +ru+ preloaded.
+
+== Similar Projects
+
+* Spring: https://github.com/rails/spring
+* Spin: https://github.com/jstorimer/spin
+* Spinoff: https://github.com/bernd/spinoff
+
+== License
+
+MIT
+
+== Author
+
+Jeremy Evans <code@jeremyevans.net>

data/bin/by

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'socket'
+
+by_server_path = ENV['BY_SOCKET'] || File.join(ENV["HOME"], '.by_socket')
+s = UNIXSocket.new(by_server_path)
+pid = s.readline("\0", chomp: true).to_i
+
+unless pid > 1
+  $stderr.puts "Invalid by_server worker pid"
+  exit(1)
+end
+
+s.send_io($stdin)
+s.send_io($stdout)
+s.send_io($stderr)
+
+s.write(Dir.pwd)
+s.write("\0")
+
+ENV.each do |k, v|
+  s.write(k)
+  s.write("=")
+  s.write(v)
+  s.write("\0")
+end
+s.write("\0")
+
+ARGV.each do |arg|
+  s.write(arg)
+  s.write("\0")
+end
+
+s.shutdown(Socket::SHUT_WR)
+exit_status = s.read
+s.close
+exit(exit_status == '0')

data/bin/by-server

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/by/server'
+
+By::Server.new.run

data/bin/by-session

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'rbconfig'
+ENV['BY_SOCKET'] ||= File.join(Dir.pwd, '.by_socket')
+by_server = File.join(__dir__, 'by-server')
+ruby = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['RUBY_INSTALL_NAME'])
+
+begin
+  system(ruby, by_server, *ARGV, exception: true)
+  system(ENV["SHELL"] || '/bin/sh')
+ensure
+  system(ruby, by_server, 'stop', exception: true)
+end

data/lib/by/server.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require 'socket'
+require_relative 'worker'
+
+module By
+  class Server
+    # Return a subclass that will use a Worker subclass with
+    # a handle_args method defined by the given block. Allows
+    # for easily customizing/overriding the default argument
+    # handling.
+    def self.with_argument_handler(&block)
+      worker_subclass = Class.new(new.default_worker_class) do
+        define_method(:handle_args, &block)
+      end
+      Class.new(self) do
+        define_method(:default_worker_class){worker_subclass}
+      end
+    end
+
+    # Creates a new server.  Arguments:
+    # socket_path: The path to the UNIX socket to create and listen on.
+    # argv: The arguments to the server, which are libraries to be required by default.
+    # debug: If set, operations on an existing server socket will be logged.
+    #        If the value is <tt>'log'</tt>, <tt>$LOADED_FEATURES</tt> will also be logged to the stdout
+    #        after libraries have been required.
+    # daemonize: Whether to daemonize, +true+ by default.
+    # daemon_args: Arguments to use when daemonizing, <tt>[false, false]</tt> by default.
+    # worker_class: The class to use for worker process handling, Worker by default.
+    def initialize(socket_path: default_socket_path, argv: default_argv, debug: default_debug,
+                   daemonize: default_daemonize, daemon_args: default_daemon_args,
+                   worker_class: default_worker_class)
+      @socket_path = socket_path
+      @argv = argv
+      @debug = debug
+      if @daemonize = !!daemonize
+        @daemon_args = Array(daemon_args)
+      end
+      @worker_class = worker_class
+    end
+
+    # The default socket path to use.  Use the +BY_SOCKET+ environment variable if set,
+    # or <tt>~/.by_socket</tt> if not set.
+    def default_socket_path
+      ENV['BY_SOCKET'] || File.join(ENV["HOME"], '.by_socket')
+    end
+
+    # The default server arguments, uses +ARGV+ by default.
+    def default_argv
+      ARGV
+    end
+
+    # The default debug mode.  This uses and removes the +DEBUG+ environment variable.
+    def default_debug
+      ENV.delete('DEBUG')
+    end
+
+    # The default for whether to daemonize. It is true if the +BY_SERVER_NO_DAEMON+
+    # environment variable is not set.
+    def default_daemonize
+      !ENV['BY_SERVER_NO_DAEMON']
+    end
+
+    # The default arguments when daemonizing.  By default, considers the 
+    # +BY_SERVER_DAEMON_NO_CHDIR+ and +BY_SERVER_DAEMON_NO_REDIR_STDIO+ environment
+    # variables.
+    def default_daemon_args
+      [!!ENV['BY_SERVER_DAEMON_NO_CHDIR'], !!ENV['BY_SERVER_DAEMON_NO_REDIR_STDIO']]
+    end
+
+    # The default worker class to use for worker processes, Worker by default.
+    def default_worker_class
+      Worker
+    end
+
+    # Runs the server.  This will not terminate until the server receives SIGTERM
+    # or stop_accepting_clients! is called manually.
+    #
+    # If stop? is true, does not run a server, just handles an existing server.
+    def run
+      handle_existing_server
+      return if stop?
+
+      handle_argv
+      setup_server
+      daemonize if daemonize?
+      setup_signals
+      accept_clients
+    end
+
+    # Handle an existing server socket.  This attempts to connect to the socket and
+    # then shutdown the server. If successful, it removes the socket.  If unnecessful,
+    # it will print an error.
+    def handle_existing_server
+      if File.socket?(@socket_path)
+        begin
+          @socket = UNIXSocket.new(@socket_path)
+          print "Shutting down existing by_server at #{@socket_path}..." if @debug
+          raise "Invalid by_server worker pid" unless @socket.readline("\0", chomp: true).to_i > 1
+          @socket.send_io($stdin)
+          @socket.send_io($stdout)
+          @socket.send_io($stderr)
+          @socket.write("stop")
+          @socket.shutdown(Socket::SHUT_WR)
+          @socket.read
+          @socket.close
+        rescue => e
+          puts "FAILED!!!" if @debug
+          $stderr.puts "Error shutting down server on existing socket: #{e.class}: #{e.message}"
+          exit(1)
+        else
+          puts "Success!" if @debug
+        end
+        @socket = nil
+        File.delete(@socket_path)
+      end
+    end
+
+    # Whether to only stop an existing server and not start a new server.
+    def stop?
+      @argv == ['stop']
+    end
+
+    # Handle arguments provided to the server.  Requires each argument by default.
+    def handle_argv
+      (auto_require_files + @argv).each{|f| require f}
+      print_loaded_features if @debug == 'log'
+    end
+
+    # Files to automatically require, uses the +BY_SERVER_AUTO_REQUIRE+ environment
+    # variable by default.
+    def auto_require_files
+      (ENV['BY_SERVER_AUTO_REQUIRE'] || '').split
+    end
+
+    # Creates and listens on the server socket.
+    def setup_server
+      # Prevent TOCTOU on server socket creation
+      umask = File.umask(077)
+      @socket = UNIXServer.new(@socket_path)
+      File.umask(umask)
+      system('chmod', '600', @socket_path)
+    end
+
+    # Daemonize with configured daemon args using Process.daemon.
+    def daemonize
+      Process.daemon(*@daemon_args)
+    end
+
+    # Whether to daemonize.
+    def daemonize?
+      !!@daemonize
+    end
+
+    # Trap SIGTERM and have it stop accepting clients.
+    # Trap SIGTERM and have it remove the socket and stop accepting clients.
+    def setup_signals
+      @sigquit_default = Signal.trap(:QUIT) do
+        stop_accepting_clients!
+      end
+      @sigterm_default = Signal.trap(:TERM) do
+        begin
+          File.delete(@socket_path)
+        rescue Errno::ENOENT
+          # server socket already deleted, ignore
+        end
+        stop_accepting_clients!
+      end
+    end
+
+    # Accept each client connection and fork a worker socket for it.
+    # Terminate loop when stop_accepting_clients! is called.
+    def accept_clients
+      while socket = accept_client
+        fork_worker(socket)
+      end
+    end
+
+    # Accept a new client connection, or return nil if
+    # stop_accepting_clients! has been called.
+    def accept_client
+      @socket.accept
+    rescue IOError, Errno::EBADF
+      # likely closed stream, return nil to exit accept_clients loop
+      nil
+    end
+
+    # Close the server socket.  This will trigger the accept_clients
+    # loop to terminate.
+    def stop_accepting_clients!
+      @socket.close
+    end
+
+    # Fork a worker process to handle the client connection.  Close the
+    # given socket after the fork, so the socket will open be open in
+    # the worker process.
+    def fork_worker(socket)
+      Process.detach(Process.fork do
+        Signal.trap(:QUIT, @sigquit_default)
+        Signal.trap(:TERM, @sigterm_default)
+        @worker_class.new(socket).run
+      end)
+      socket.close
+    end
+
+    # Print <tt>$LOADED_FEATURES</tt> to stdout.
+    def print_loaded_features
+      puts $LOADED_FEATURES
+    end
+  end
+end

data/lib/by/worker.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+    
+module By
+  class Worker
+    # Whether the worker process should signal a normal exit to the client.
+    # The default is nil, which signals a normal exit when the worker
+    # process exits normally.  This can be set to false to signal an
+    # abnormal exit, such as to indicate test failures.
+    attr_writer :normal_exit 
+
+    # Create the worker.  Arguments
+    # socket :: The Unix socket to use to communicate with the client.
+    # sigterm_handler
+    def initialize(socket)
+      @socket = socket
+      @normal_exit = nil
+    end
+
+    # Run the worker process.
+    def run
+      write_pid
+      reopen_stdio
+      chdir_or_stop
+      replace_env
+      handle_args(get_args)
+    end
+
+    # Write the current process pid to the client, to signal that
+    # the worker process is ready.
+    def write_pid
+      @socket.write($$.to_s)
+      @socket.write("\0")
+    end
+
+    # Replace stdin, stdout, stderr with the IO values provided by the client.
+    def reopen_stdio
+      $stdin.reopen(@socket.recv_io(IO))
+      $stdout.reopen(@socket.recv_io(IO))
+      $stderr.reopen(@socket.recv_io(IO))
+    end 
+
+    # Change to the given directory, unless the client is telling the
+    # worker to stop the server.
+    def chdir_or_stop
+      arg = @socket.readline("\0", chomp: true)
+      arg == 'stop' ? stop_server : chdir(arg)
+    end
+
+    # Stop the server process by sending it the SIGQUIT signal, then exit.
+    def stop_server
+      Process.kill(:QUIT, Process.ppid)
+      cleanup_proc.call
+      exit
+    end
+
+    # Change to the given directory.
+    def chdir(dir)
+      Dir.chdir(dir)
+    end
+
+    # Print <tt>$LOADED_FEATURES</tt> to stdout.
+    def print_loaded_features
+      puts $LOADED_FEATURES
+    end
+
+    # A proc for communicating exit status to the client, and
+    # printing the loaded features if configured.  Used during
+    # process shutdown.
+    def cleanup_proc
+      proc do
+        if @normal_exit.nil?
+          @normal_exit = $!.nil? || ($!.is_a?(SystemExit) && $!.success?)
+        end
+        @socket.write(@normal_exit ? '0' : '1')
+        @socket.shutdown(Socket::SHUT_WR)
+        @socket.close
+        print_loaded_features if ENV['DEBUG'] == 'log'
+      end
+    end
+
+    # Replace ENV with the environment provided by the client.
+    def replace_env
+      env = {}
+      while line = @socket.readline("\0", chomp: true)
+        break if line.empty?
+        k, v = line.split("=")
+        env[k] = v
+      end
+      ENV.replace(env)
+    end
+
+    # An array of arguments provided by the client.
+    def get_args
+      args = []
+      while !@socket.eof?
+        args << @socket.readline("\0", chomp: true)
+      end
+      args
+    end
+
+    # Handle arguments provided by the client.  Ensure correct
+    # client after handling the arguments.
+    def handle_args(args)
+      worker = self
+      cleanup = cleanup_proc
+
+      case arg = args.first
+      when 'm', /\.rb:\d+\z/
+        args.shift if arg == 'm'
+        ARGV.replace(args)
+        require 'm'
+        M.define_singleton_method(:exit!) do |exit_code|
+          worker.normal_exit = exit_code == true
+          cleanup.call
+          super(exit_code)
+        end
+        M.run(args)
+      when 'irb'
+        at_exit(&cleanup)
+        args.shift
+        ARGV.replace(args)
+        require 'irb'
+        IRB.start(__FILE__)
+      when '-e'
+        at_exit(&cleanup)
+        unless args.length >= 2
+          $stderr.puts 'no code specified for -e (RuntimeError)'
+          exit(1)
+        end
+        args.shift
+        code = args.shift
+        ARGV.replace(args)
+        ::TOPLEVEL_BINDING.eval(code)
+      when String
+        args.shift
+        ARGV.replace(args)
+
+        begin
+          require File.expand_path(arg)
+        rescue
+          @normal_exit = false
+          at_exit(&cleanup)
+          raise
+        end
+
+        if defined?(Minitest) && Minitest.class_variable_get(:@@installed_at_exit)
+          Minitest.singleton_class.prepend(Module.new do
+            define_method(:run) do |argv|
+              super(argv).tap{|exit_code| p worker.normal_exit = exit_code == true}
+            end
+          end)
+          Minitest.after_run(&cleanup)
+        else
+          at_exit(&cleanup)
+        end
+      else
+        # no arguments
+        at_exit(&cleanup)
+        ::TOPLEVEL_BINDING.eval($stdin.read)
+      end
+    end
+  end
+end
+

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: by
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jeremy Evans
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-02-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest-global_expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  by is a library preloader for ruby designed to speed up process startup.
+  It uses a client/server approach, where the server loads the libraries and
+  listens on a UNIX socket, and the client connects to that socket to run
+  processes.  For each client connection, the server forks a worker process,
+  which uses the current directory, stdin, stdout, stderr, and environment
+  of the client process.  The worker process then processes the arguments
+  provided by the client. The client process waits until the worker process
+  closes the socket, which the worker process attempts to do right before
+  it exits.
+email: code@jeremyevans.net
+executables:
+- by
+- by-server
+- by-session
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+- CHANGELOG
+- MIT-LICENSE
+files:
+- CHANGELOG
+- MIT-LICENSE
+- README.rdoc
+- bin/by
+- bin/by-server
+- bin/by-session
+- lib/by/server.rb
+- lib/by/worker.rb
+homepage: http://github.com/jeremyevans/by
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/jeremyevans/by/issues
+  changelog_uri: https://github.com/jeremyevans/by/blob/master/CHANGELOG
+  mailing_list_uri: https://github.com/jeremyevans/by/discussions
+  source_code_uri: https://github.com/jeremyevans/by
+post_install_message:
+rdoc_options:
+- "--quiet"
+- "--line-numbers"
+- "--inline-source"
+- "--title"
+- 'by: Ruby library preloader'
+- "--main"
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.1
+signing_key:
+specification_version: 4
+summary: Ruby library preloader
+test_files: []