ready 0.0.1 → 0.0.2

data/rakelib/ready.rake

@@ -0,0 +1,191 @@
+require "shellwords"
+require "open3"
+require "bundler"
+require "rake/clean"
+require "ready"
+
+configuration = Ready::Configuration.new
+
+PROJECT_DIR = configuration.project_path
+EXE_DIR = PROJECT_DIR / "exe"
+EXTRA_DIR = PROJECT_DIR / "extra"
+READY_PREFIX = configuration.prefix
+READY_SOCKET = configuration.sock_path
+READY_BUILD_DIR = configuration.build_dir
+READYFILE = configuration.readyfile
+
+def run_command(*args, out: $stdout, chdir: Dir.pwd, **kwargs)
+  case args
+  in Hash => env, *cmd
+  in cmd then env = {}
+  end
+
+  puts
+  puts cmd.join(" ")
+
+  Bundler.with_unbundled_env do
+    Open3.popen2(env, *cmd.map(&:to_s), chdir: chdir.to_s, **kwargs) do |sin, sout, wait|
+      sin.close
+      IO.copy_stream sout, out
+      result = wait.value
+      raise "Encountered an error while running #{cmd.join(" ").inspect}" unless result.success?
+    end
+  end
+end
+
+def compile_by(target:)
+  shell_load_path = [EXE_DIR, ENV.fetch("PATH", "")].join ":"
+  env = ENV.to_h.merge(
+    "PATH" => shell_load_path,
+    "BY_SOCKET" => READY_SOCKET.to_s,
+  )
+  File.open target, "w" do |f|
+    run_command env, "ready", "compile", "by", "--no-rubygems", "--no-yjit", out: f
+  end
+end
+
+def compile_gem(executable_name, target:)
+  shell_load_path = [EXE_DIR, ENV.fetch("PATH", "")].join ":"
+  env = ENV.to_h.merge("PATH" => shell_load_path)
+
+  File.open target, "w" do |f|
+    run_command env, "ready", "compile", "--environment", "BY_SOCKET=#{READY_SOCKET}", executable_name, out: f
+  end
+end
+
+namespace :ready do
+  directory PROJECT_DIR do
+    mkdir_p PROJECT_DIR
+  end
+
+  directory READY_PREFIX do
+    mkdir_p READY_PREFIX
+  end
+
+  directory READY_BUILD_DIR do
+    mkdir_p READY_BUILD_DIR
+  end
+
+  Rake::Task[READY_BUILD_DIR].invoke
+
+  build_tempdir = READY_PREFIX / "tmp"
+
+  directory build_tempdir do
+    mkdir_p build_tempdir
+  end
+
+  trace_dir = READY_PREFIX / "traces"
+
+  directory trace_dir do
+    mkdir_p trace_dir
+  end
+
+  ri_bootstrapper = EXTRA_DIR / "ri.rb"
+
+  file ri_bootstrapper do
+    raise "RI patch should already exist at #{ri_bootstrapper.to_s.inspect}"
+  end
+
+  file READYFILE do
+    touch READYFILE.to_s
+  end
+
+  ready_path = EXE_DIR / "ready"
+
+  file ready_path do
+    raise "ready executable not found at #{ready_path}"
+  end
+
+  extra = READY_PREFIX / "extra.rb"
+
+  CLEAN.include FileList[build_tempdir, READY_BUILD_DIR]
+  CLOBBER.include FileList[READY_BUILD_DIR.parent / "**/*"]
+
+  env = {
+    "JRUBY_OPTS" => "--dev -J--enable-native-access=ALL-UNNAMED",
+    "MINITEST_ACTIVATE_SKIP" => 1,
+    "RUBY_YJIT_ENABLE" => 1,
+    "BUNDLE_IGNORE_CONFIG" => 1,
+    "BY_SOCKET" => READY_SOCKET,
+  }.transform_values(&:to_s)
+
+  file extra do
+    extra_body = <<~RUBY
+      if defined? ActiveSupport
+        ActiveSupport.to_time_preserves_timezone = true
+        ActiveSupport.deprecator.silenced = true
+        ActiveSupport.eager_load!
+      end
+
+      if defined? Zeitwerk
+        Zeitwerk::Registry.loaders.each { it.eager_load(force: true) }
+      end
+    RUBY
+    File.write extra, extra_body
+  end
+
+  file READY_SOCKET => [extra, ri_bootstrapper, READYFILE] do
+    puts "Loading server..."
+    run_command env, "by-server", *READYFILE.gem_names, ri_bootstrapper.to_s, extra.to_s, chdir: Dir.home
+  end
+
+  core_deps = FileList[READY_BUILD_DIR, trace_dir, ready_path]
+
+  desc "Start the ready server"
+  task start_server: READY_SOCKET do
+    puts "Starting ready server"
+  end
+
+  desc "Stop the ready server"
+  task :stop_server do
+    puts "Stopping ready server"
+    rm_f READY_SOCKET
+    run_command env, "by-server", "stop"
+  end
+
+  desc "Restart the ready server"
+  task restart_server: [:stop_server, :start_server]
+
+  namespace :build do
+    irb = READY_BUILD_DIR / "ready_irb"
+
+    ready_by = READY_BUILD_DIR / "ready_by"
+
+    file ready_by => core_deps do |task, _|
+      compile_by target: task.name
+    end
+
+    file irb => core_deps do |task, _|
+      compile_gem "irb", target: task.name
+    end
+
+    READYFILE.each_executable do |executable|
+      file executable.realpath => core_deps do |task, _|
+        compile_gem executable.name, target: task.name
+      end
+    end
+
+    all_executables = FileList[ready_by, *READYFILE.executable_paths]
+
+    compiled = READY_BUILD_DIR.parent / "builds.zwc"
+
+    file compiled => all_executables do |task, _|
+      pathname = Pathname(task.name)
+      run_command "zsh", "-c",
+                  Shellwords.join(["zcompile", "-Uz", pathname.basename.to_s, *all_executables]),
+                  chdir: pathname.parent
+    end
+
+    CLEAN.import all_executables
+
+    multitask compile: [compiled, *all_executables]
+  end
+
+  desc "Compile all ready executables"
+  task compile: "build:compile"
+
+  task compile_and_clean: [:compile, :clean]
+end
+
+desc "Build and start the ready environment"
+multitask ready: ["ready:restart_server", "ready:compile_and_clean"]

data/readyfile

@@ -0,0 +1,10 @@
+# gems: are preloaded into the warm by-server, which does `require <entry>`
+# verbatim -- so each entry must be a REQUIRE PATH, not a gem name. Both the
+# ronin library (`require "ronin"`) and ronin-support (`require "ronin/support"`,
+# NOT "ronin-support", which is a LoadError) are preloaded so the ronin CLI's
+# own code is already warm in the server, not just its support library.
+gems:
+  - ronin
+  - ronin/support
+executables:
+  - ronin

data/zsh/ready/functions/ready/__ready_datetime

@@ -0,0 +1,32 @@
+##
+# __ready_datetime
+#
+# Usage: __ready_datetime $EPOCHREALTIME (or other epoch timestamp)
+#
+emulate -L zsh
+
+setopt extendedglob pipefail errreturn
+
+zmodload zsh/datetime
+
+local input=$1
+local secs=${input%%.*}
+local iso zone frac
+
+if [[ $input = *.* ]]; then
+  frac=${input#*.}
+fi
+
+if [[ -n $frac ]]; then
+  frac="${frac}000"        # pad so we always have >= 3 digits
+  frac=${frac[1,3]}        # millis
+fi
+
+strftime -s iso  '%Y-%m-%dT%H:%M:%S' $secs
+strftime -s zone '%z'                $secs   # e.g. +0000 / -0400 (no colon)
+
+if [[ -n $frac ]]; then
+  REPLY="${iso}.${frac}${zone}"
+else
+  REPLY="${iso}${zone}"
+fi

data/zsh/ready/functions/ready/__ready_debug

@@ -0,0 +1,51 @@
+##
+# ready_log <debug|info|warn|error>
+#
+emulate -L zsh
+
+setopt extendedglob pipefail errreturn warncreateglobal warnnestedvar
+
+zmodload zsh/datetime
+
+autoload -Uz __ready_datetime __ready_print
+
+local level
+local configured_level=${READY_LOGLEVEL:-info}
+local -a rest
+local -A mapping=(
+  debug yellow
+  info cyan
+  warn magenta
+  error red
+)
+
+if (( $+mapping[$1] )); then
+  level=$1
+  rest=("${(@)@[2,-1]}")
+else
+  level=info
+  rest=("${(@)@}")
+fi
+
+if [[ -z ${(j::)rest} ]]; then
+  print -u2 "must enter a debug message"
+  return 1
+fi
+
+if (( READY_DEBUG )); then
+  configured_level=debug
+fi
+
+local -A rank=(debug 0 info 1 warn 2 error 3)
+
+if (( ${rank[$level]:-1} >= ${rank[$configured_level]:-1} )); then
+  local REPLY
+  __ready_datetime $EPOCHREALTIME
+  {
+    if [[ $READY_LOG_PATH = /dev/(stdin|stderr|tty) && -t 1 ]]; then
+      __ready_print -c $mapping[$level] "[%B${REPLY}%b]" "[%B${(U)level}%b]" $rest
+    else
+      __ready_print "[${REPLY}]" "[${(U)level}]" $rest
+    fi
+  } >> $READY_LOG_PATH
+fi

data/zsh/ready/functions/ready/__ready_print

@@ -0,0 +1,55 @@
+#autoload
+
+emulate -L zsh
+
+setopt errreturn warncreateglobal warnnestedvar
+
+local -A opt_args
+local -a print_opts
+local string
+
+zparseopts \
+  -D \
+  -E \
+  -K \
+  -A \
+  opt_args \
+  - \
+  v: \
+  c: \
+  -color: \
+  -var:
+(( ? != 0 )) && return 1
+
+local var
+
+if (( $+opt_args[--var] )); then
+  print_opts+=(-v ${opt_args[--var]##=})
+fi
+
+if (( $+opt_args[-v] )); then
+  print_opts+=(-v ${opt_args[-v]})
+fi
+
+local color
+local i
+if (( $+opt_args[--color] )) || (( $+opt_args[-c] )); then
+  i=${opt_args[(i)(--color|--color=|-c)]}
+  color=${opt_args[${i##=}]}
+fi
+
+integer string_start_index=${@[(i)[^-]*]}
+integer string_end_index=${#@}
+print_opts+=(${@[1,$((string_start_index - 1))]})
+string="${@[$string_start_index, $string_end_index]}"
+
+if [[ -n $color ]]; then
+  string="%F{$color}${string}%f"
+  if ! (( $print_opts[(I)-P] )); then
+    print_opts+=(-P)
+  fi
+else
+  print_opts+=(--)
+fi
+
+builtin print $print_opts $string

data/zsh/ready/functions/readyinit

@@ -0,0 +1,78 @@
+#autoload
+# Initializes "ready" functions and completions
+
+emulate -L zsh
+
+setopt extendedglob warncreateglobal warnnestedvar localtraps
+
+trap 'local rc=$?; local str="$0: Something went wrong initialzing ready"; __ready_debug error $str; return $rc' ZERR
+
+autoload -Uz __ready_debug
+autoload -Uz compdef
+
+local fn
+local compiledpath=$READY_PREFIX/builds.zwc
+local possible_basename
+local possible_declared_completion_fn
+local -a noncompletions
+
+compiledpath=${compiledpath:P}
+
+if ! [[ -f $compiledpath ]]; then
+  print -u2 "Compiled path ${compiledpath} does not exist. Please run 'readyup' to create it."
+  return 1
+fi
+
+# Not exposed publicly yet, but this decides during the `autoload -Uz -w` of the zwc wordcode file whether or not to add the +X flag.
+# If enabled, pay a (small) penalty on `ready init`, for consistent performance on the first command call
+# If disabled, `ready init` is faster, but lazy load the source from the zwc on the first command call
+typeset -gx READY_ZSH_EAGER_LOAD=1
+
+# Point the `by` client at the ready server's socket. Gem stubs set BY_SOCKET
+# inline per call, but the bare `by`/`ready_by` command relies on the env; the
+# by client otherwise defaults to ~/.by_socket and can't reach the server.
+typeset -gx BY_SOCKET=$READY_SOCK_PATH
+
+noncompletions=(${${${${${(f@)"$(builtin zcompile -t $compiledpath)"}[2,-1]}:t}:#_*}:#ready})
+__ready_debug debug "Found the following functions (non-completion)"
+__ready_debug debug "${(F)noncompletions}"
+
+__ready_debug debug "Compiled path is $compiledpath. Adding to fpath"
+fpath+=($compiledpath)
+
+__ready_debug debug "Now running zcompile..."
+# this loads the entire ready.zwc package in one call, and creates autoload stubs
+# for each of the ready_* functions. They will be fully loaded upon being called for the first
+# time.
+if (( READY_ZSH_EAGER_LOAD == 1 )); then
+  builtin autoload -w +X -Uz $compiledpath
+else
+  builtin autoload -w -Uz $compiledpath
+fi
+
+__ready_debug debug "Zcompile done"
+
+for fn in $noncompletions; do
+  possible_basename=${fn#ready_}
+  possible_declared_completion_fn=$READY_COMPLETIONS_DIR/_$fn
+
+  __ready_debug info "RUN builtin alias -- $possible_basename=$fn"
+  builtin alias -- $possible_basename=$fn
+
+  if (( $+_comps[$fn] )); then
+    __ready_debug warn "_$fn already defined: ${(j: -> :)${(kv)_comps[$fn]}}. Skipping..."
+    continue
+  fi
+
+  if [[ -f $possible_declared_completion_fn ]]; then
+    __ready_debug info "Found _$fn function at $possible_declared_completion_fn"
+    autoload -Uz _$fn
+    compdef _$fn $fn
+    continue
+  fi
+
+  if (( $+_comps[$possible_basename] )); then
+    __ready_debug info "RUN compdef _${possible_basename} $fn"
+    compdef _${possible_basename} $fn
+  fi
+done

data/zsh/ready/functions/readyup

@@ -0,0 +1,64 @@
+#autoload
+# Shortcut for running "rake ready in ready project dir"
+
+emulate -L zsh
+
+zmodload -F zsh/files b:zf_rm b:zf_mkdir
+
+setopt extendedglob
+setopt pipefail
+setopt errreturn
+setopt warnnestedvar
+setopt warncreateglobal
+
+autoload -Uz readyinit __ready_debug __ready_print
+
+local -a tounfun
+local -a tounalias
+
+local tmpdir=${READY_PREFIX:?}
+local readydir=${READY_SRC_DIR:?}
+local rc
+
+tounfun=(${functions[(I)_(#c0,1)ready_*]} ready_by)
+tounalias=(${${tounfun:t}/#*ready_})
+
+(
+  local al
+  for al in $tounalias; do
+    if (( $+aliases[$al] )); then
+      builtin unalias $al &>/dev/null
+    else
+      __ready_debug info "Alias $al not found. Skipping unalias..."
+    fi
+  done
+
+  for al in $tounfun; do
+    if (( $+functions[$al] )); then
+      builtin unfunction $al &>/dev/null
+    else
+      __ready_debug info "Function $al not found. Skipping unalias..."
+    fi
+  done
+
+  builtin cd -q $readydir
+
+  if ! (( $+commands[rbenv] )); then
+    string="%B%rbenv%b was not found. Cannot continue"
+    __ready_print -c red $string
+    __ready_debug error $string
+    return 1
+  fi
+
+  command rbenv exec ruby --disable=gems -W0 -S rake --verbose ready
+)
+rc=$?
+
+if (( rc != 0 )); then
+  string="Encountered error(%B$rc%b) while running compilation task. Cannot continue. Run %Bready clobber%b to reset the build, then open a new shell to rebuild."
+  __ready_print -c red $string
+  __ready_debug error $string
+  return $rc
+fi
+
+readyinit

data/zsh/ready/functions/rizz

@@ -0,0 +1,50 @@
+#autoload
+
+emulate -L zsh
+
+setopt pipefail
+setopt errreturn
+setopt warnnestedvar
+setopt warncreateglobal
+
+autoload -Uz print_colors
+autoload -Uz opt_read
+autoload -Uz ruby
+autoload -Uz ready_ri
+print_colors
+
+local -A opt_args
+
+zparseopts \
+  -D \
+  -E \
+  -K \
+  -A \
+  opt_args \
+  -F \
+  - \
+  -no-glow \
+  -pager
+(( ? != 0 )) && return 1
+
+local -a glow_args
+local no_glow=false
+
+opt_read -c pager && glow_args+=(--pager)
+opt_read opt_args no-glow && no_glow=true
+
+# for some reason ruby is faster for running this formatting script than "by"? I wonder why - main component of that script is prism
+ready_ri ${@} \
+  | {
+  if $no_glow; then
+    gcat
+  else
+    ruby ~/repos/formatter.rb \
+    |  command gawk '
+	/```ruby/{block=1; print; next}
+	/```/{block=0; print; next}
+	block==1{gsub(/^    /,"")}
+	{print} ' \
+      | ptywrap -- glow ${glow_args}
+  fi
+}

data/zsh/ready/ready.plugin.zsh

@@ -0,0 +1,49 @@
+# run in subshell so that it can do its thing without tampering with fpath, PATH, other globals
+
+() {
+  setopt pipefail
+
+  zmodload zsh/files
+  zmodload -m -F zsh/files b:zf_\*
+
+  local __FILE__=${${(%)${:-%x}}:A}
+  local __DIR__=${__FILE__:h:A}
+  typeset -gx READY_COMPLETIONS_DIR=${__DIR__:h}/site-functions
+  typeset -gx READY_PREFIX=${READY_PREFIX:-/tmp/ready}
+  typeset -gx READY_LOG_PATH=${READY_LOG_PATH:-${READY_PREFIX}/ready.log}
+  typeset -gx READY_DEBUG=${READY_DEBUG:-0}
+  typeset -gx READY_SRC_DIR=${__DIR__:h:h}
+  typeset -gx READY_SOCK_PATH=${READY_SOCK_PATH:-${READY_PREFIX}/ready.sock}
+
+  if ! [[ -d $READY_PREFIX ]]; then
+    zf_mkdir -p $READY_PREFIX
+  fi
+
+  fpath+=($__DIR__/functions $__DIR__/functions/ready $READY_COMPLETIONS_DIR)
+
+  autoload -Uz readyup readyinit __ready_debug __ready_print
+
+  local rc=1
+
+  if [[ -S $READY_SOCK_PATH ]]; then
+    __ready_debug debug "Sock found, returning"
+    readyinit
+
+    return
+  fi
+
+  __ready_debug debug "Sock not found, creating"
+
+  if ! (( $+parameters[RBENV_SHELL] )); then
+    __ready_debug warn "RBENV_SHELL not detected"
+  fi
+
+  readyup; rc=$?
+
+  if (( rc )); then
+    autoload -Uz __ready_print
+    __ready_print -u2 -c red "Ready failed to initialize. Check %B${READY_LOG_PATH}%b for more info"
+  fi
+
+  return $rc
+}

data/zsh/ready.plugin.zsh

@@ -0,0 +1 @@
+ready/ready.plugin.zsh

data/zsh/site-functions/_ready_ronin

@@ -0,0 +1,12 @@
+#compdef ready_ronin
+
+autoload -Uz _ronin
+
+# need to call this once to get _ronin_completions loaded
+_ronin &>/dev/null
+
+# set ${_comps[ready_ronin]} to "_bash_complete -F _ronin_completions", and
+# then remove this "bootstrapper" function. After this is done, the zsh-bash handler takes
+# over.
+compdef _bash_complete\ -F\ _ronin_completions ready_ronin
+unfunction _ready_ronin

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ready
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - David Gillis
@@ -9,6 +9,34 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: by
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: command_kit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -36,9 +64,45 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- demo/demofns.zsh
+- demo/rubyconf.rec
 - exe/ready
+- extra/browse.sh
+- extra/finder.sh
+- extra/formatter
+- extra/formatter.rb
+- extra/ri.rb
+- extra/rif
+- extra/rif2
+- issues.rec
 - lib/ready.rb
+- lib/ready/by_executable.rb
+- lib/ready/cli.rb
+- lib/ready/cli/clobber.rb
+- lib/ready/cli/compile.rb
+- lib/ready/cli/init.rb
+- lib/ready/cli/rake_command.rb
+- lib/ready/cli/up.rb
+- lib/ready/configuration.rb
+- lib/ready/executable.rb
+- lib/ready/executable/multiple_files_error.rb
+- lib/ready/fn.zsh.erb
+- lib/ready/readyfile.rb
+- lib/ready/readyfile/executable.rb
 - lib/ready/version.rb
+- lib/ready/zsh_function.rb
+- lib/ready/zsh_script.rb
+- rakelib/ready.rake
+- readyfile
+- zsh/ready.plugin.zsh
+- zsh/ready/functions/ready/__ready_datetime
+- zsh/ready/functions/ready/__ready_debug
+- zsh/ready/functions/ready/__ready_print
+- zsh/ready/functions/readyinit
+- zsh/ready/functions/readyup
+- zsh/ready/functions/rizz
+- zsh/ready/ready.plugin.zsh
+- zsh/site-functions/_ready_ronin
 licenses:
 - MIT
 metadata:
@@ -50,14 +114,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 4.0.1
+      version: 3.4.7
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.11
+rubygems_version: 4.0.15
 specification_version: 4
 summary: A new Ruby gem
 test_files: []