ready 0.0.1 → 0.0.2

data/extra/rif

@@ -0,0 +1,478 @@
+#!/usr/bin/env zsh
+arr_debug () {
+  emulate -L zsh
+  print_colors
+  local expression=${@} 
+  if [[ -z ${expression} ]]
+  then
+    printerr_bold_red "Must pass an expression"
+    return 1
+  fi
+  setopt pipefail
+  expression=${(qqq)expression} 
+  print -u2 -P -r "%B%F{cyan} -- [DEBUG] -- %f%b %F{green}[%N]%f %B%F{cyan} -- %f%b %F{cyan}${expression}%f"
+}
+ slurp () {
+  emulate -L zsh
+  setopt errreturn
+  local varname=${1:-""} 
+  zslurp
+  local NL=$'\x0a' 
+  REPLY=${REPLY%%${NL}} 
+  if [[ -z ${varname} ]]
+  then
+    return
+  fi
+  if (( $+parameters[$varname] ))
+  then
+    if [[ ${parameters[$varname]} =~ local ]]
+    then
+      eval "${(q)varname}=${(qqq)REPLY}"
+    else
+      typeset -g ${varname}=${REPLY}
+    fi
+  else
+    typeset -g ${varname}=${REPLY}
+  fi
+  REPLY="" 
+}
+ by_gem () {
+  by_gem () {
+    emulate -L zsh
+    if (( $+parameters[RUBYOPT] ))
+    then
+      local -x RUBYOPT=${RUBYOPT:-""} 
+      local -a rubyopt=(${(z)RUBYOPT}) 
+      rubyopt=(${rubyopt:#*bundler/setup}) 
+      rubyopt=(${rubyopt:#*bundler/setup.rb}) 
+      typeset -p rubyopt >&2
+      RUBYOPT=${(j: :)rubyopt} 
+    fi
+    by -e "$(
+            cat <<'RUBY'
+      # frozen_string_literal: true
+
+#--
+# Copyright 2006 by Chad Fowler, Rich Kilmer, Jim Weirich and others.
+# All rights reserved.
+# See LICENSE.txt for permissions.
+#++
+
+require "rubygems/gem_runner"
+
+Gem::GemRunner.new.run ARGV.clone
+
+RUBY
+      )" "$@"
+  }
+  by_gem "${@}"
+}
+ str_split () {
+  emulate -L zsh
+  print_colors
+  local -A opt_args
+  zparseopts -A opt_args -D -E -F -K -delimiter: d:
+  local input=${1} 
+  local string
+  local delimiter=z 
+  opt_read --infer-short opt_args delimiter && delimiter=${REPLY} 
+  if [[ -z ${input} ]]
+  then
+    printerr_bold_red "Input must be present"
+  elif [[ -v ${input} ]]
+  then
+    string=${(P)input} 
+  else
+    string=${input} 
+  fi
+  unset reply
+  typeset -ga reply
+  if [[ ${delimiter} = z ]]
+  then
+    set -A reply ${(Az)string}
+  elif [[ ${delimiter} = f ]]
+  then
+    set -A reply ${(Af)string}
+  elif [[ ${delimiter} = 0 ]] || [[ delimiter = '0' ]]
+  then
+    set -A reply ${(A0)string}
+  elif [[ ${delimiter} = ':' ]]
+  then
+    set -A reply ${(pAs%:%)string}
+  else
+    set -A reply ${(pAs:$delimiter:)string}
+  fi
+}
+ print_colors () {
+  
+}
+ opt_read () {
+  emulate -L zsh
+  setopt extendedglob
+  local -A optread_opts
+  zparseopts -A optread_opts -D -F - c -canonical -infer-short i
+  if (( ? != 0 ))
+  then
+    print -u2 "Error parsing options"
+    return 1
+  fi
+  local canonical=false 
+  local input
+  local opt_name
+  if aa_key optread_opts -c || aa_key optread_opts --canonical
+  then
+    canonical=true 
+  fi
+  if $canonical
+  then
+    input=opt_args 
+    opt_name=$1 
+  else
+    input=$1 
+    opt_name=$2 
+  fi
+  if $canonical || aa_key optread_opts --infer-short || aa_key optread_opts -i
+  then
+    local first_letter=${opt_name[1]} 
+    local -a input_keys=(${(Pk)input}) 
+    local -a short_matching_keys=(${(M)input_keys:##-${first_letter}}) 
+    integer key_count=${#short_matching_keys} 
+    if (( key_count > 1 ))
+    then
+      print -u2 "Ambiguous short option: ${first_letter}. Matches:$'\n' ${(F)short_matching_keys}"
+      return 1
+    elif (( key_count == 1 ))
+    then
+      opt_name=${short_matching_keys[1]#-} 
+    fi
+  fi
+  if [[ -z ${input} ]]
+  then
+    print -u2 "Must pass an input"
+    return 1
+  fi
+  if ! [[ ${opt_name} =~ '^-{1,2}' ]]
+  then
+    if ((${#opt_name} > 1))
+    then
+      opt_name="--${opt_name}" 
+    else
+      opt_name="-${opt_name}" 
+    fi
+    if aa_key ${input} ${opt_name}
+    then
+      REPLY=${${${(P)input}[${opt_name}]/=/}:-true} 
+      return 0
+    else
+      unset REPLY
+      return 1
+    fi
+  else
+    return 1
+  fi
+}
+ arr_empty () {
+  emulate -L zsh
+  print_colors
+  local arr_name=${1} 
+  if [[ -z ${arr_name} ]]
+  then
+    printerr_red "Must pass array name"
+    return 1
+  fi
+  if [[ ${arr_name} = argv ]]
+  then
+    printerr_red "Cannot check argv. Use a different name"
+    return 1
+  fi
+  setopt pipefail
+  if ! [[ ${(t)${(P)arr_name}} =~ array ]]
+  then
+    printerr_red "Input is not an array"
+    return 1
+  fi
+  if (( ${#${(P)arr_name}} == 0 ))
+  then
+    return 0
+  else
+    return 2
+  fi
+}
+ rif () {
+  emulate -L zsh
+  setopt extendedglob
+  print_colors
+  local -A opt_args
+  zparseopts -D -E -K -A opt_args - i -interactive -forcebat -no-strip n
+  (( ? != 0 )) && return 1
+  local interactive=false 
+  local no_strip=false 
+  local forcebat=false 
+  opt_read -c no-strip && no_strip=$REPLY 
+  opt_read -c interactive && interactive=$REPLY 
+  opt_read opt_args forcebat && forcebat=true 
+  local -a bat_options=(${(M)@:#-*}) 
+  set -- ${@:|bat_options}
+  local query=${1:?} 
+  integer index=${2:-0} 
+  local -a all
+  str_split -d '::' query
+  arr_map -v reply '${(j:_:)it}' '${it//(#b)([A-Z][^A-Z](#c1,))([A-Z][^A-Z](#c,))/${(j:_:)match}}' '${(L)it}'
+  local gem_name=$reply[1] 
+  local -a rest=(${reply[2,-1]}) 
+  if (( $#rest == 0 ))
+  then
+    rest=($gem_name) 
+  elif (( $#rest > 0 ))
+  then
+    local alt_gem_name=$gem_name-$rest[1] 
+  fi
+  arr_join -d '/' rest
+  local relpath=${REPLY}.rb 
+  by_gem contents $alt_gem_name $gem_name ${gem_name//_/} | wind -v1 all
+  local -Ua results
+  results=(${(M)${(M)all:%*.rb}:%*/lib/*/${~relpath}}) 
+  if arr_empty results
+  then
+    print -u2 -P "%F{red}Found no results%f"
+    return 1
+  elif $interactive
+  then
+    local -a abbrev=(${results//#*${gem_name}/${gem_name}}) 
+    local -a results=(${results:^abbrev}) 
+    print -r -C2 -a -- $results | command fzf --with-nth=2 --ansi --preview-window='70%,wrap' --preview "bat --language=ruby --color=always {1}"
+  elif (( $#results > 1 )) && (( index == 0 ))
+  then
+    print -u2 -P "%F{blue}Found more than 1 result:%f"
+    print -r -l -- $results
+    return 0
+  fi
+  if (( index == 0 ))
+  then
+    index=1 
+  elif (( index > $#results ))
+  then
+    print -u2 -P "%F{red}Index out of bounds: %B$index%b > %B$#results%b%f"
+    return 1
+  fi
+  local filepath=${results[$index]} 
+  local presented_filepath=${filepath##*gems/} 
+  bat_options+=(--file-name $presented_filepath) 
+  {
+    if $no_strip
+    then
+      command gcat $filepath
+    else
+      command ggrep --color=auto --binary-files=text -Pv '^\s*#?\s*$' $filepath
+    fi
+  } | command tab2space -t2 | {
+    if [[ -t 1 ]] || $force_bat
+    then
+      command bat --color=always --no-paging --language=ruby $bat_options
+    else
+      col -b
+    fi
+  }
+}
+ val_arr () {
+  emulate -L zsh
+  print_colors
+  local -A opt_args
+  local is_quiet=false 
+  zparseopts -D -E -K -A opt_args -F - -quiet -silent s q
+  (( ? != 0 )) && return 1
+  if opt_read -c quiet || opt_read -c silent
+  then
+    is_quiet=true 
+  fi
+  local arr_name=${1} 
+  if [[ -z ${arr_name} ]]
+  then
+    $is_quiet || printerr_bold_red "Must pass an array name"
+    return 1
+  fi
+  if [[ ${arr_name} =~ '\$\{' ]] || [[ ${arr_name} =~ ' ' ]]
+  then
+    $is_quiet || printerr_bold_red "Must pass name of array, not expression"
+    return 1
+  fi
+  if ! [[ ${(Pt)arr_name} =~ array ]]
+  then
+    $is_quiet || printerr_bold_red "'${arr_name}' is not an array"
+    return 1
+  fi
+  setopt pipefail
+}
+ arr_clone () {
+  emulate -L zsh
+  print_colors
+  setopt extendedglob
+  local arr_name
+  local clone_name
+  if (( # == 1 ))
+  then
+    arr_name=reply 
+    clone_name=${1} 
+  else
+    arr_name=${1} 
+    clone_name=${2} 
+  fi
+  val_arr ${arr_name}
+  setopt pipefail
+  set -A ${clone_name} ${(P)arr_name}
+}
+ wind () {
+  emulate -L zsh
+  zmodload zsh/mapfile
+  setopt extendedglob
+  setopt errreturn
+  local quotes
+  local file
+  local variation='-v3' 
+  zparseopts -D -K -E -F - v::=variation f::=file -file::=file q=quotes -quotes=quotes
+  local arrayname=${1:-reply} 
+  local input=/dev/stdin 
+  local use_quotes=false 
+  local NL=$'\x0a' 
+  if [[ -n $file ]]
+  then
+    input=${file##-(#c1,2)f(ile)(#c,1)(=| (#c,))} 
+    print -v input ${~input/%/(#q-NA)}
+    if (( ${#input} != ${#${input## (#c,)}} )) || [[ -z ${input} ]]
+    then
+      {
+        print -u2 -P -- "%B%F{red}Your file input contains ambiguous prefix spacing:%b"
+        typeset -p file >&2
+        print -u2 -P -- "%BCorrect it and try again%b%f"
+        return 1
+      }
+    fi
+  fi
+  if [[ $quotes = "-q" ]] || [[ $quotes = '--quotes' ]]
+  then
+    use_quotes=true 
+  fi
+  if [[ $input = /dev/stdin ]]
+  then
+    slurp
+    if ${use_quotes}
+    then
+      set -A ${arrayname} ${(qqq@f)REPLY}
+    else
+      case $variation in
+        ("-v1") set -A ${arrayname} "${(@f)REPLY%${NL}}" ;;
+        ("-v2") set -A ${arrayname} "${(@f)REPLY}" ;;
+        ("-v3") set -A ${arrayname} ${(@f)REPLY} ;;
+      esac
+    fi
+  elif [[ -r ${input} ]]
+  then
+    case $variation in
+      ("-v1") set -A ${arrayname} "${(f@)${mapfile[${input}]%${NL}}}" ;;
+      ("-v2") set -A ${arrayname} "${(f@)${mapfile[${input}]}}" ;;
+      ("-v3") set -A ${arrayname} ${(f@)${mapfile[${input}]}} ;;
+    esac
+  else
+    print -u2 -P "%F{red}Error. Unknown options specified: %B${(qq)@}%b%f"
+    return 1
+  fi
+}
+ arr_map () {
+  emulate -L zsh
+  setopt extendedglob
+  print_colors
+  local -A opt_args
+  local to_evaluate
+  unset MATCH
+  zparseopts -A opt_args -D -E -F -- e -echo p v -verbose
+  local arr_name=${1} 
+  if ! val_arr ${arr_name}
+  then
+    return 1
+  fi
+  local -a expressions=(${(Oa)${@[2,-1]}}) 
+  if (( ${#expressions} == 0 ))
+  then
+    printerr_bold_red "Must pass at least one expression"
+    return 1
+  fi
+  local exp1=${expressions[1]//it/MATCH} 
+  local i
+  for i in ${expressions[2,-1]}
+  do
+    i=${${i}//it/MATCH} 
+    exp1=${exp1//MATCH/"${i}"} 
+  done
+  builtin print -v to_evaluate -r -- "set -A reply \${\${(P)arr_name}/(#m)*/\${${exp1}}}"
+  if opt_read -c verbose
+  then
+    arr_debug ${to_evaluate}
+  fi
+  eval ${to_evaluate}
+  if opt_read -c echo
+  then
+    print -r -- ${reply}
+  fi
+}
+ arr_join () {
+  emulate -L zsh
+  print_colors
+  local -A opt_args
+  zparseopts -A opt_args -D -E -F -K -delimiter: d:
+  local arr_name=${1} 
+  local delimiter=z 
+  local NUL=$'\x00' 
+  if ! val_arr ${arr_name}
+  then
+    return 1
+  fi
+  opt_read --infer-short opt_args delimiter && delimiter=${REPLY} 
+  if [[ ${delimiter} = z ]]
+  then
+    REPLY=${(j: :)${(P)arr_name}} 
+  elif [[ ${delimiter} = 0 ]] || [[ delimiter = '0' ]]
+  then
+    REPLY=${(pj:$NUL:)${(P)arr_name}} 
+  elif [[ ${delimiter} = ':' ]]
+  then
+    REPLY=${(pj%:%)${(P)arr_name}} 
+  else
+    REPLY=${(pj:$delimiter:)${(P)arr_name}} 
+  fi
+}
+ aa_key () {
+  emulate -L zsh
+  local input=${1} 
+  local key_name=${2} 
+  if [[ -z ${input} ]]
+  then
+    print -u2 "Must pass name of associative array"
+    return 1
+  fi
+  if [[ -z ${key_name} ]]
+  then
+    print -u2 "Must pass name of key"
+    return 1
+  fi
+  if [[ ${${(P)input}[(I)${key_name}]} = ${key_name} ]]
+  then
+    return 0
+  else
+    return 1
+  fi
+}
+ zslurp () {
+  emulate -L zsh -o no_multibyte
+  zmodload zsh/system || return
+  local -a content
+  local -i i=0 
+  while true
+  do
+    sysread 'content[++i]' && continue
+    (( $? == 5 )) || return
+    break
+  done
+  typeset -g REPLY=${(j::)content} 
+}
+
+rif ${@}

data/extra/rif2

@@ -0,0 +1,58 @@
+#!/usr/bin/env zsh
+rif2 () {
+  emulate -L zsh
+  setopt pipefail
+  setopt errreturn
+  setopt warnnestedvar
+  setopt warncreateglobal
+  {
+    time by -e '
+    require "flexor"
+    require "command_kit/colors"
+    require "irb/source_finder"
+include CommandKit::Colors::ANSI
+duck_context = F.new.tap do |f|
+  f.workspace.binding = binding
+end
+
+constant = ARGV.first.to_s
+constant_no_trailing = ARGV.first.to_s.gsub(/:*$/,"")
+unless (constant_no_trailing.constantize rescue false)
+	begin
+	  underscored_no_trailing = constant_no_trailing.underscore.gsub(/\/*$/,"")
+	  warn yellow("Constant #{bold(constant_no_trailing.inspect)} not ready. Attempting to require #{bold(underscored_no_trailing.inspect)}")
+	  require underscored_no_trailing
+	rescue LoadError
+	  puts red("Error: #{bold(underscored_no_trailing.inspect)} not found")
+	  exit 1
+	end
+end
+
+source = IRB::SourceFinder
+	.new(duck_context)
+	.find_source(constant_no_trailing)
+
+if source.nil?
+  puts red("Error: No results found" )
+  exit 1
+end
+
+source_path = Pathname(source.file)
+gem_path = Pathname(Gem.paths.home)
+path = source_path.relative_path_from gem_path
+puts path
+puts source.file_content
+' $@
+  } | {
+    local filepath
+    read filepath
+    if [[ $line =~ "Error:" ]]
+    then
+      print -r -- $filepath
+    else
+        command tab2space -t2 | command bat --color=always --language=ruby --file-name="$filepath" --theme=Coldark-Dark
+    fi
+  }
+}
+
+rif2 ${@}

data/issues.rec

@@ -0,0 +1,79 @@
+%rec: Issue
+%key: Id
+%typedef: text_t regexp /.*/
+%typedef: Status_t enum open in_progress complete
+%type: Id int
+%type: Name line
+%type: Summary text_t
+%type: Status Status_t
+%type: Created date
+%auto: Id Created
+%mandatory: Name Summary Status
+
+Id: 0
+Created: Sun, 08 Mar 2026 17:22:28 -0400
+Name: Rubygems struggles with conflicting gem versions
+Summary: Say you have:
++ gem_a as a dep, where gem_a is dependent on `BigDecimal, >= '3.3.0'`
++ gem_b as a dep, where gem_b is dependent on `BigDecimal, ~> '3.3.0'`
++ 
++ If gem_a is loaded first, and latest present version of BigDecimal is 4.0.1, loading gem_b will raise error when it tries to load big_decimal, as rubygems is greedy.
++ 
++ Possible solutions:
++ - Dynamically create a gemfile on the spot, so that a lockfile is produced prior to booting by-server
++ - Try to mitigate load order (currently doing this as a quick fix)
+Status: open
+
+Id: 1
+Created: Sun, 08 Mar 2026 17:36:16 -0400
+Name: Need to patch by.gem source with my modifications
+Summary: Currently the following support is broken, or is not fully implemented in by:
++ 3. process sub (e.g. /dev/fd/12 support when that is used as a file)
++ 2. sigint should be ignored when using irb
++ 1. there are still random irb failures
+Status: open
+
+Id: 2
+Created: Wed, 01 Apr 2026 10:59:52 -0400
+Name: Ruby codeblocks preceded by "   #" get mangled when using Rizz
+Summary: Rizz output shown below for the ruby "box" rdoc:
++ "
++  # in foo.rb
++   class String
++   BLANK_PATTERN = /\A\s*\z/
++   def blank?
++   self =~ BLANK_PATTERN
++   end
++   end
++ 
++     module Foo
++       def self.foo = "foo"
++ 
++       def self.foo_is_blank?
++     foo.blank?
++       end
++     end
++ 
++     Foo.foo.blank? #=> false
++     "foo".blank?   #=> false
++ 
++     # in main.rb
++     box = Ruby::Box.new
++     box.require('foo')
++ 
++     box::Foo.foo_is_blank? #=> false   (#blank? called in box)
++ 
++     "foo".blank?          # NoMethodError
++     String::BLANK_PATTERN # NameError
++ 
++   The main box and  box  are different boxes, so monkey patches in main
++   are also invisible in  box .
++ "
++ Rizz formats correctly starting at "module Foo", but everything before it is not formatted. The raw markdown adds a tab indent before "# in foo.rb", which likely messes things up.
+Status: open
+
+Id: 3
+Created: Sat, 18 Apr 2026 10:36:11 -0400
+Name: Why are functions in zwc prefixed with their full absolute paths?
+Summary: Things appear to be working, possibly by accident. I should investigate this further
+Status: open

data/lib/ready/by_executable.rb

@@ -0,0 +1,51 @@
+require "shellwords"
+
+module Ready
+  ##
+  # Builds the ruby invocation used to run the "by" executable, toggling
+  # rubygems and YJIT, and renders it as a shell alias.
+  class ByExecutable
+    def initialize(
+      current_ruby: RbConfig.ruby,
+      by_bin: Gem.activate_bin_path("by", "by")
+    )
+      @current_ruby = current_ruby
+      @by_bin = by_bin
+      @args = []
+    end
+
+    def without_rubygems
+      @args << "--disable-gems" unless @args.include? "--disable-gems"
+      self
+    end
+
+    def with_rubygems
+      @args.delete "--disable-gems"
+      self
+    end
+
+    def with_yjit
+      @args << "--yjit"
+      self
+    end
+
+    def without_yjit
+      @args.delete("--yjit")
+      self
+    end
+
+    def command_args
+      [
+        @current_ruby,
+        *@args,
+        @by_bin,
+      ]
+    end
+
+    def to_alias
+      command_args
+        .then { Shellwords.join(it) }
+        .then { "#{it} \"${@}\"" }
+    end
+  end
+end

data/lib/ready/cli/clobber.rb

@@ -0,0 +1,21 @@
+require "command_kit/command"
+
+module Ready
+  class CLI
+    ##
+    # Removes every compiled ready build artifact, by delegating to the
+    # `rake clobber` task.
+    class Clobber < CommandKit::Command
+      include RakeCommand
+
+      description "Remove all compiled ready build artifacts"
+
+      #
+      # Runs `rake clobber`.
+      #
+      def run
+        rake("clobber")
+      end
+    end
+  end
+end