ready 0.0.1 → 0.0.2

data/lib/ready/cli/compile.rb

@@ -0,0 +1,111 @@
+require "command_kit/command"
+
+module Ready
+  class CLI
+    ##
+    # Compiles ready stubs and prints them to stdout, or compiles everything via
+    # rake:
+    #
+    # * `ready compile` / `ready compile all`: compile every stub
+    #   (`rake ready:compile`) -- bare `compile` defaults to `all`, like `make`
+    # * `ready compile by`: the persistent `by` client alias
+    # * `ready compile NAME ...`: a zsh function stub per CLI name
+    #
+    # The `--rubygems`/`--yjit` flags only apply to `by`; `--environment` only
+    # applies to named CLIs.
+    class Compile < CommandKit::Command
+      include RakeCommand
+
+      usage "[options] [all | by | NAME [NAME ...]]"
+
+      option :environment, short: "-e",
+                           value: {
+                             type: String,
+                             usage: "KEY=VALUE",
+                           },
+                           desc: "Environment variable to set for the compiled CLI (repeatable)" do |pair|
+                             key, value = pair.split("=", 2)
+                             if value.nil? || key.empty?
+                               print_error "invalid --environment #{pair.inspect}; expected KEY=VALUE"
+                               exit(1)
+                             end
+                             @environment[key] = value
+                           end
+
+      option :rubygems, long: "--[no-]rubygems",
+                        desc: "(by only) Load rubygems. Off by default for a big speed boost"
+
+      option :yjit, long: "--[no-]yjit",
+                    desc: "(by only) Enable YJIT. Off by default"
+
+      argument :names, required: false,
+                       repeats: true,
+                       usage: "all | by | NAME",
+                       desc: "`all` (the default when omitted), `by`, or one or more CLI names to compile"
+
+      description "Compile ready stubs for the given CLI name(s)"
+
+      examples [
+        "",
+        "all",
+        "by --yjit",
+        "irb rspec",
+        "-e RAILS_ENV=production rails",
+      ]
+
+      #
+      # Seeds the per-invocation environment accumulator that the `-e` option
+      # block writes into. The `--rubygems`/`--yjit` booleans are read straight
+      # from {#options}, which command_kit populates for us.
+      #
+      def initialize(**kwargs)
+        super
+
+        @environment = {}
+      end
+
+      #
+      # Dispatches on the argument(s): `all` compiles everything via rake, `by`
+      # prints the persistent-client alias, and anything else is treated as one
+      # or more gem/CLI names.
+      #
+      # @param [Array<String>] names
+      #
+      def run(*names)
+        case names
+        in [] | ["all"] then rake("ready:compile")
+        in ["by"] then print by_alias
+        else
+          reject_reserved_names!(names)
+          print gem_script(names)
+        end
+      end
+
+      private
+
+      def by_alias
+        executable = ByExecutable.new
+        executable = options[:rubygems] ? executable.with_rubygems : executable.without_rubygems
+        executable = options[:yjit] ? executable.with_yjit : executable.without_yjit
+        executable.to_alias
+      end
+
+      def gem_script(names)
+        ZshScript.new(names: names, environment: @environment).to_s
+      end
+
+      #
+      # `all` and `by` are whole-invocation modes, not gem names; reject them
+      # when they are mixed with other names rather than trying to compile a gem
+      # literally called "all" or "by".
+      #
+      def reject_reserved_names!(names)
+        reserved = names & %w[all by]
+        return if reserved.empty?
+
+        print_error "#{reserved.join(", ")} cannot be combined with other names"
+        exit(1)
+      end
+    end
+  end
+end

data/lib/ready/cli/init.rb

@@ -0,0 +1,30 @@
+require "command_kit/command"
+
+module Ready
+  class CLI
+    ##
+    # Prints the shell snippet that sources ready's zsh plugin. The plugin path
+    # is resolved by introspection relative to this gem, so the output is
+    # correct wherever the gem is installed:
+    #
+    #     eval "$(ready init)"      # or paste the line into ~/.zshrc
+    class Init < CommandKit::Command
+      # The bundled zsh plugin entry point, resolved relative to the gem.
+      PLUGIN_PATH = Ready.root / "zsh" / "ready" / "ready.plugin.zsh"
+
+      description "Print the zsh snippet that sources the ready plugin"
+
+      #
+      # Prints `source <plugin path>` to stdout.
+      #
+      def run
+        unless PLUGIN_PATH.file?
+          print_error "ready zsh plugin not found at #{PLUGIN_PATH}"
+          exit(1)
+        end
+
+        puts "source #{PLUGIN_PATH}"
+      end
+    end
+  end
+end

data/lib/ready/cli/rake_command.rb

@@ -0,0 +1,32 @@
+require "English"
+require "rbconfig"
+
+module Ready
+  class CLI
+    ##
+    # Shared behaviour for sub-commands that delegate to the project's Rakefile
+    # (`up`, `clobber`, and `compile all`).
+    #
+    # Rake is run under the same Ruby that is running `ready`, inheriting
+    # whatever Bundler context `exe/ready` established: in a development checkout
+    # a Gemfile is present, so `exe/ready` has already required `bundler/setup`
+    # (propagated to the rake process and the `ready compile` sub-processes it
+    # spawns via `RUBYOPT`); in production there is no Gemfile, so the build runs
+    # bundler-free and resolves the installed gem through RubyGems.
+    module RakeCommand
+      ##
+      # Runs the given rake task(s) in {Ready.root} and exits non-zero if rake
+      # fails.
+      #
+      # @param [Array<String>] tasks
+      #   The rake task name(s) to run.
+      def rake(*tasks)
+        return if system(RbConfig.ruby, "-S", "rake", *tasks, chdir: Ready.root.to_s)
+
+        # Propagate rake's own exit status where we can; fall back to 1 if the
+        # process could not be spawned at all ($? unset).
+        exit($CHILD_STATUS&.exitstatus || 1)
+      end
+    end
+  end
+end

data/lib/ready/cli/up.rb

@@ -0,0 +1,21 @@
+require "command_kit/command"
+
+module Ready
+  class CLI
+    ##
+    # Compiles every stub and (re)starts the ready server, by delegating to the
+    # `rake ready` task.
+    class Up < CommandKit::Command
+      include RakeCommand
+
+      description "Compile all stubs and start the ready server"
+
+      #
+      # Runs `rake ready`.
+      #
+      def run
+        rake("ready")
+      end
+    end
+  end
+end

data/lib/ready/cli.rb

@@ -0,0 +1,24 @@
+require "command_kit/commands"
+require "command_kit/options/version"
+
+module Ready
+  ##
+  # The `ready` command-line interface.
+  #
+  # `ready` speeds up Ruby CLI startup by preloading executables into a
+  # persistent server and compiling thin zsh stubs that dispatch to it. This
+  # class wires the sub-commands together with command_kit; each sub-command
+  # lives in its own file under `cli/`.
+  class CLI
+    include CommandKit::Commands
+    include CommandKit::Options::Version
+
+    command_name "ready"
+    version Ready::VERSION
+
+    command Init
+    command Up
+    command Compile
+    command Clobber
+  end
+end

data/lib/ready/configuration.rb

@@ -0,0 +1,60 @@
+module Ready
+  ##
+  # Resolves ready's runtime configuration (paths, prefixes, the readyfile)
+  # from the environment, falling back to conventional defaults.
+  class Configuration
+    def project_path
+      Pathname(__dir__).parent.parent.expand_path
+    end
+
+    def prefix
+      fetched = fetch_env :prefix, default: "/tmp/ready"
+
+      Pathname(fetched).expand_path
+    end
+
+    def build_dir
+      prefix / "builds"
+    end
+
+    def sock_path
+      fetched = fetch_env :sock_path do
+        prefix / "ready.sock"
+      end
+
+      Pathname(fetched)
+    end
+
+    def readyfile
+      @readyfile ||= open_readyfile
+    end
+
+    private
+
+    def open_readyfile
+      fetched = fetch_env :readyfile do
+        Pathname(Dir.home) / ".readyfile"
+      end
+
+      Readyfile.open(fetched, build_dir:)
+    end
+
+    def fetch_env(key, default: nil, &block)
+      key = key.to_s.upcase
+      value = ENV.fetch("READY_#{key}") { resolve_fallback(key, default, block) }
+      raise "Expected value of #{key} to not be empty" if value.empty?
+
+      value
+    end
+
+    def resolve_fallback(key, default, block)
+      case [default, block]
+      in String, nil then default
+      in nil, Proc then block.call
+      in nil, nil then raise "Expected ENV var #{key} to be found but was not"
+      else
+        raise ArgumentError, "args #{key.inspect}, default: #{default.inspect}, block: #{block.inspect} are invalid"
+      end
+    end
+  end
+end

data/lib/ready/executable/multiple_files_error.rb

@@ -0,0 +1,3 @@
+##
+# Raised when an executable name resolves to more than one candidate file.
+class Ready::Executable::MultipleFilesError < StandardError; end

data/lib/ready/executable.rb

@@ -0,0 +1,94 @@
+require "stringio"
+
+module Ready
+  ##
+  # Resolves an executable name (gem-provided or on-disk) to a concrete path
+  # and renders its source with a process title prelude.
+  class Executable
+    attr_reader :name, :is_gem
+
+    # Executables whose gem name differs from the command, so `path` isn't a
+    # wall of one-off special cases.
+    GEM_BIN_OVERRIDES = {
+      "bundle" => %w[bundler bundle],
+      "ri" => %w[rdoc ri],
+      "yri" => %w[yard yri],
+      "rstore" => %w[reversal-store rstore],
+      "rougify" => %w[rouge rougify],
+    }.freeze
+
+    SHEBANG_LINE = /^.*#!.*\n/
+    REQUIRE_RELATIVE = /(require_relative(?:\(| )\s*[\x27"]([^\s\x27"]+)[\x27"]\)?)/
+
+    def initialize(name)
+      @name = name
+      @is_gem = !File.exist?(name)
+    end
+
+    # "bin/<name>" when the executable sits directly in a bin directory, else
+    # the bare basename. Anchored on the parent directory's name so a path like
+    # /home/robin/foo doesn't match "bin" as a substring.
+    def convert_path_to_bin(path)
+      pathname = Pathname(path)
+      pathname.dirname.basename.to_s == "bin" ? "bin/#{pathname.basename}" : pathname.basename
+    end
+
+    def render
+      stream = StringIO.new
+      stream.puts
+      stream.puts(
+        <<~RUBY,
+          Process.setproctitle #{name.inspect}
+        RUBY
+      )
+      stream.puts(source)
+      stream.string
+    end
+
+    def path
+      @path ||= @is_gem ? gem_executable_path : on_disk_path
+    end
+
+    def source
+      raise "No executable found for '#{@name}'" if path.nil?
+
+      @source ||= rewrite_require_relative(File.read(path).gsub(SHEBANG_LINE, "").strip)
+    end
+
+    private
+
+    def on_disk_path
+      if @name.to_s.include?("exe")
+        resolved = @name
+        @name = @name.split("/").last
+        return resolved
+      end
+      convert_path_to_bin(@name)
+    end
+
+    def gem_executable_path
+      override = GEM_BIN_OVERRIDES[@name]
+      return Gem.bin_path(*override) if override
+      return `rbenv which gem`.chomp if @name == "gem"
+
+      gem_path
+    end
+
+    # Rewrites `require_relative "x"` to an absolute `require`, so the source
+    # can be eval'd by the persistent server outside its original directory.
+    def rewrite_require_relative(code)
+      return code unless code.include?("require_relative")
+
+      code.scan(REQUIRE_RELATIVE).each do |statement, relpath|
+        absolute = (Pathname(path).dirname / relpath).expand_path.to_s
+        rewritten = statement.gsub("require_relative", "require").gsub(relpath, absolute)
+        code = code.gsub(statement, rewritten)
+      end
+      code
+    end
+
+    def gem_path
+      Gem.bin_path(@name, @name)
+    end
+  end
+end

data/lib/ready/fn.zsh.erb

@@ -0,0 +1,28 @@
+# AUTO-GENERATED ZSH FUNCTION VIA ready.rb
+#
+ready_<%= name %> () {
+  emulate -L zsh
+
+  setopt pipefail errreturn warncreateglobal warnnestedvar
+
+  autoload -Uz __ready_debug
+  autoload -Uz ready_by
+
+  <% # having bundler/setup set as a require in `RUBYOPT` causes all sorts # of issues when making a stub around a persistent server.
+  # Remove it if present, careful not to slow things down by spawning subshells
+  %>
+  if (( $+parameters[RUBYOPT] ))
+  then
+    __ready_debug "Detected RUBYOPT present: ${(kv)parameters[RUBYOPT]}"
+    local -x RUBYOPT=${RUBYOPT:-""}
+    local -a rubyopt=(${(z)RUBYOPT})
+
+    rubyopt=(${rubyopt:#*bundler/setup})
+    rubyopt=(${rubyopt:#*bundler/setup.rb})
+    RUBYOPT=${(j: :)rubyopt}
+    __ready_debug "Sanitized RUBYOPT: ${(kv)parameters[RUBYOPT]}"
+  fi
+
+  <%= env.map { |pair| pair.join("=")  }.join(" ") %> ready_by \
+    -e <%= ruby.shellescape %> "$@"
+}

data/lib/ready/readyfile/executable.rb

@@ -0,0 +1,46 @@
+##
+# A single executable declared in a readyfile, mapping its name to the
+# compiled path under the build directory.
+class Ready::Readyfile::Executable
+  attr_reader :name, :prefix, :build_dir
+
+  def initialize(name, build_dir:, prefix: "ready_")
+    @name = name
+    @prefix = prefix
+    @build_dir = Pathname(build_dir)
+
+    validate!
+  end
+
+  def mapping
+    { name => realpath }
+  end
+
+  def ready_name
+    prefix + name
+  end
+
+  def realpath
+    build_dir / ready_name
+  end
+
+  private
+
+  def validate!
+    validate_name!
+    validate_build_dir!
+  end
+
+  def validate_name!
+    raise ArgumentError, "Name cannot be nil" if name.nil?
+    raise ArgumentError, "Name cannot be empty" if name.empty?
+  end
+
+  def validate_build_dir!
+    raise ArgumentError, "build_dir cannot be nil for executable #{name.inspect}" if build_dir.nil?
+    return if build_dir.directory?
+
+    raise ArgumentError,
+          "build_dir #{build_dir.inspect} must exist for executable #{name.inspect}"
+  end
+end

data/lib/ready/readyfile.rb

@@ -0,0 +1,73 @@
+require "yaml"
+
+module Ready
+  ##
+  # Reads the YAML readyfile and exposes the gems and executables it declares.
+  class Readyfile
+    attr_reader :config, :build_dir, :path
+
+    def self.open(path, build_dir:)
+      path = Pathname(path)
+      # A missing, empty, or null readyfile is not an error: it simply declares
+      # no gems or executables. YAML.parse_file returns false for an empty file,
+      # and a document such as "---" parses to nil.
+      # YAML.parse_file returns `false` for an empty file (not nil), so guard on
+      # truthiness, not with `&.` -- false&.to_ruby would blow up. A "---"
+      # document is truthy but to_ruby's to nil, which the `|| {}` folds to empty.
+      document = (YAML.parse_file(path.to_s) if path.exist?)
+      config = (document ? document.to_ruby : {}) || {}
+
+      unless config.is_a?(Hash)
+        raise Error, "#{path}: readyfile must be a YAML mapping of gems:/executables:, got #{config.class}"
+      end
+
+      new config, build_dir:, path:
+    end
+
+    def initialize(config, build_dir:, path:)
+      @path = path
+      @config = config
+      @build_dir = build_dir
+    end
+
+    def to_path
+      path
+    end
+
+    def to_s
+      path.to_s
+    end
+
+    def gem_names
+      config.fetch("gems", [])
+    end
+
+    def executables
+      config
+        .fetch("executables", [])
+        .map { Executable.new it, build_dir: }
+    end
+
+    def executable_names
+      executables.map(&:name)
+    end
+
+    def executable_paths
+      executables.map(&:realpath)
+    end
+
+    def each_executable_mapping(&)
+      return enum_for __method__ unless block_given?
+
+      executables.flat_map(&:mapping).each do |mapping|
+        yield(*mapping.to_a)
+      end
+    end
+
+    def each_executable
+      return enum_for __method__ unless block_given?
+
+      executables.each { yield it }
+    end
+  end
+end

data/lib/ready/version.rb

@@ -1,3 +1,3 @@
 module Ready
-  VERSION = "0.0.1".freeze
+  VERSION = "0.0.2".freeze
 end

data/lib/ready/zsh_function.rb

@@ -0,0 +1,27 @@
+require "erb"
+
+module Ready
+  ##
+  # Renders a zsh function that wraps an executable, using the bundled ERB
+  # template.
+  class ZshFunction
+    attr_reader :name, :executable, :environment, :template_path
+
+    DEFAULT_TEMPLATE_PATH = Pathname(__dir__) / "fn.zsh.erb"
+    def initialize(name, environment: {}, template_path: DEFAULT_TEMPLATE_PATH)
+      @name = name
+      @environment = environment
+      @executable = Executable.new(name)
+      @template_path = Pathname(template_path)
+    end
+
+    def to_s
+      template = ERB.new(@template_path.read)
+      template.result_with_hash(
+        name: name,
+        ruby: executable.render,
+        env: environment,
+      )
+    end
+  end
+end

data/lib/ready/zsh_script.rb

@@ -0,0 +1,45 @@
+require "stringio"
+
+module Ready
+  ##
+  # Assembles a zsh script by rendering one ZshFunction per name, building the
+  # functions concurrently.
+  class ZshScript
+    attr_accessor :names
+    attr_reader :environment
+
+    def initialize(names: [], environment: {})
+      @names = names
+      @environment = environment
+      @mutex = Mutex.new
+      @script = StringIO.new
+    end
+
+    def multithread_process(names)
+      threads = names.map do |name|
+        Thread.new do
+          zsh_body = ZshFunction.new(name, environment: environment).to_s
+          @mutex.synchronize do
+            @script.puts zsh_body
+          end
+        end
+      end
+
+      threads.each(&:join)
+    end
+
+    def set_env(key, value)
+      @environment[key] = value
+    end
+
+    def add_eager_loading!
+      #    @source.puts 'by -e "ActiveSupport.eager_load!"'
+    end
+
+    def to_s
+      add_eager_loading!
+      multithread_process(@names)
+      @script.string
+    end
+  end
+end

data/lib/ready.rb

@@ -1,12 +1,24 @@
 require "zeitwerk"
+require "pathname"
+require "shellwords"
 
 ##
 # Top-level namespace for the ready gem.
 module Ready
   LOADER = Zeitwerk::Loader.for_gem
+  LOADER.inflector.inflect("cli" => "CLI")
   LOADER.setup
 
   ##
   # Base error class for ready.
   class Error < StandardError; end
+
+  ##
+  # The root directory of the ready gem (the parent of `lib/`). Used to locate
+  # bundled assets such as the zsh plugin and the Rakefile.
+  #
+  # @return [Pathname]
+  def self.root
+    Pathname(__dir__).parent
+  end
 end