uprb 0.1.0

data/lib/uprb/cli.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "optparse"
+require_relative "../uprb"
+
+module Uprb
+  class CLI
+    USAGE = <<~USAGE.chomp
+    Usage:
+      uprb pack <src.rb> <dest>
+      uprb gem install <gem> [--path DIR]
+      uprb gem pack <gem> [--path DIR]
+    USAGE
+
+    def self.start(argv = ARGV)
+      new(argv).run
+    end
+
+    def initialize(argv)
+      @argv = argv.dup
+    end
+
+    def run
+      command = @argv.shift
+
+      case command
+      when "pack"
+        pack_command
+      when "gem"
+        gem_command
+      when "--version", "-v"
+        $stdout.puts(Uprb::VERSION)
+      when "--help", "-h", nil
+        $stdout.puts(USAGE)
+      else
+        $stderr.puts(USAGE)
+      end
+    rescue Uprb::Error => e
+      $stderr.puts("uprb: #{e.message}")
+      exit 1
+    rescue StandardError => e
+      $stderr.puts("uprb: #{e.class}: #{e.message}")
+      exit 1
+    end
+
+    private
+
+    def pack_command
+      options, args = parse_pack_options(@argv)
+      src = args.shift or raise Uprb::Error, "missing <src.rb>"
+      dest = args.shift or raise Uprb::Error, "missing <dist>"
+
+      src_path = File.expand_path(src)
+      dest_path = File.expand_path(dest)
+
+      raise Uprb::Error, "source not found: #{src}" unless File.file?(src_path)
+
+      FileUtils.mkdir_p(File.dirname(dest_path))
+      return unless confirm_overwrite(dest_path, options)
+
+      Uprb::RequireReplacer.pack(src_path, dest_path:, requires: options[:requires], dynamic: options[:dynamic], script_argv: options[:script_argv], skip_disable_gems: options[:skip_disable_gems], skip_ruby_path_replace: options[:skip_ruby_path_replace])
+
+      $stdout.puts("Packed #{dest_path}")
+    end
+
+    def gem_command
+      subcommand = @argv.shift
+
+      case subcommand
+      when "install"
+        options, args = parse_pack_options(@argv)
+        gem_name = args.shift or raise Uprb::Error, "missing <gem>"
+        install_gem(gem_name)
+        pack_gem_executables(gem_name, options)
+      when "pack"
+        options, args = parse_pack_options(@argv)
+        gem_name = args.shift or raise Uprb::Error, "missing <gem>"
+        pack_gem_executables(gem_name, options)
+      else
+        $stdout.puts(USAGE)
+      end
+    end
+
+    def parse_pack_options(argv)
+      if (separator_index = argv.index("--"))
+        script_argv = argv[(separator_index + 1)..]
+        argv = argv[0...separator_index]
+      else
+        script_argv = []
+      end
+
+      options = {
+        path: nil,
+        force: false,
+        requires: [],
+        dynamic: false,
+        script_argv: script_argv,
+        skip_disable_gems: false,
+        skip_ruby_path_replace: false,
+      }
+      parser = OptionParser.new
+      parser.on("--path DIR") do |dir|
+        options[:path] = dir
+      end
+      parser.on("-f", "--force", "overwrite existing destination without prompting") do
+        options[:force] = true
+      end
+      parser.on("-r", "--require LIB", "pre-require LIB at pack time and at runtime (repeatable)") do |lib|
+        options[:requires] << lib
+      end
+      parser.on("--with-rubygems", "shortcut for --require rubygems") do
+        options[:requires] << "rubygems"
+      end
+      parser.on("--dynamic", "execute the entry script at pack time to observe runtime-only requires") do
+        options[:dynamic] = true
+      end
+      parser.on("--skip-disable-gems", "drop --disable-gems from the shebang (vendoring only; trades fast startup for normal Ruby startup)") do
+        options[:skip_disable_gems] = true
+      end
+      parser.on("--skip-ruby-path-replace", "keep the source file's shebang ruby invocation instead of rewriting it to an absolute RbConfig.ruby path (vendoring only; source must have a shebang)") do
+        options[:skip_ruby_path_replace] = true
+      end
+      args = parser.parse(argv)
+
+      [options, args]
+    rescue OptionParser::ParseError => e
+      raise Uprb::Error, e.message
+    end
+
+    def confirm_overwrite(dest_path, options)
+      return true if options[:force]
+      return true unless File.exist?(dest_path)
+
+      unless $stdin.tty?
+        raise Uprb::Error, "destination already exists: #{dest_path} (pass --force to overwrite)"
+      end
+
+      $stderr.print("uprb: #{dest_path} already exists. overwrite? [y/N]: ")
+      answer = $stdin.gets
+      return true if answer && answer.strip.match?(/\A(y|yes)\z/i)
+
+      $stdout.puts("skipped #{dest_path}")
+      false
+    end
+
+    def install_gem(gem_name)
+      command = [RbConfig.ruby, "-S", "gem", "install", gem_name]
+      system(*command) or raise Uprb::Error, "gem install failed: #{gem_name}"
+    end
+
+    def pack_gem_executables(gem_name, options)
+      spec = Gem::Specification.find_by_name(gem_name)
+      executables = spec.executables
+      raise Uprb::Error, "no executables for gem: #{gem_name}" if executables.empty?
+      bindir = spec.bindir
+
+      dest_dir = options[:path] ? File.expand_path(options[:path]) : Gem.bindir
+      FileUtils.mkdir_p(dest_dir)
+
+      executables.each do |exe|
+        source_path = File.join(spec.full_gem_path, bindir, exe)
+        raise Uprb::Error, "executable not found: #{source_path}" unless File.file?(source_path)
+
+        dest_path = File.join(dest_dir, exe)
+
+        next unless confirm_overwrite(dest_path, options)
+
+        Uprb::RequireReplacer.pack(source_path, dest_path:, requires: options[:requires], dynamic: options[:dynamic], script_argv: options[:script_argv], skip_disable_gems: options[:skip_disable_gems], skip_ruby_path_replace: options[:skip_ruby_path_replace])
+        $stdout.puts("Packed #{dest_path}")
+      end
+    rescue Gem::LoadError => e
+      raise Uprb::Error, e.message
+    end
+  end
+end

data/lib/uprb/require_replacer.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "rbconfig"
+require "tempfile"
+
+module Uprb
+  module RequireReplacer
+    class << self
+      attr_reader :mapping
+
+      def pack(source_path, dest_path: nil, requires: [], dynamic: false, script_argv: [], skip_disable_gems: false, skip_ruby_path_replace: false)
+        source = File.read(source_path)
+        mapping = build_mapping(source_path, requires, dynamic, script_argv)
+        embedded, external = build_payload(mapping)
+        ruby_source = source_with_require_hook(source, requires)
+        main_iseq = RubyVM::InstructionSequence.compile(ruby_source, source_path, source_path)
+        payload = Marshal.dump({
+          embedded: embedded,
+          external: external,
+          main: main_iseq.to_binary
+        })
+
+        shebang = resolve_shebang(source, skip_ruby_path_replace: skip_ruby_path_replace, skip_disable_gems: skip_disable_gems)
+        body = <<~RUBY
+          DATA.binmode
+          data = Marshal.load(DATA)
+
+          EMBEDDED_ISEQ = data.fetch(:embedded)
+          REQUIRE_MAP = data.fetch(:external)
+
+          iseq = RubyVM::InstructionSequence.load_from_binary(data.fetch(:main))
+          iseq.eval
+          __END__
+        RUBY
+
+        if shebang
+          program = "#{shebang}\n#{body}#{payload}"
+          return program unless dest_path
+          File.write(dest_path, program)
+          FileUtils.chmod("+x", dest_path)
+        else
+          program = body + payload
+          return program unless dest_path
+          File.write(dest_path, program)
+        end
+      end
+
+      private
+
+      def resolve_shebang(source, skip_ruby_path_replace:, skip_disable_gems:)
+        first_line = source.lines.first&.chomp
+        return nil unless first_line&.start_with?("#!")
+
+        ruby_command = skip_ruby_path_replace ? first_line[2..] : RbConfig.ruby
+        skip_disable_gems ? "#!#{ruby_command}" : "#!#{ruby_command} --disable-gems"
+      end
+
+      # `--dynamic` alone would miss literal requires in branches the
+      # execution didn't take (rescued `LoadError` alternates, unused
+      # autoloads, feature-flag branches); the static walk fills those in.
+      def build_mapping(source_path, requires, dynamic, script_argv)
+        return Uprb::StaticRequireTracker.trace(source_path, requires: requires) unless dynamic
+
+        dynamic_map = execute_with_tracker(source_path, requires, script_argv)
+        static_map = Uprb::StaticRequireTracker::StaticWalker.new.walk(File.expand_path(source_path))
+        static_map.merge(dynamic_map)
+      end
+
+      def rewind_read_tempfile(file)
+        file.flush
+        file.rewind
+        file.read
+      end
+
+      def execute_with_tracker(path, requires = [], script_argv = [])
+        original_stdout, original_stderr = STDOUT.dup, STDERR.dup
+        original_argv = ARGV.dup
+        original_program_name = $PROGRAM_NAME
+        tmp_stdout = Tempfile.new("uprb-stdout")
+        tmp_stderr = Tempfile.new("uprb-stderr")
+        mapping = nil
+
+        begin
+          STDOUT.reopen(tmp_stdout)
+          STDERR.reopen(tmp_stderr)
+          ARGV.replace(script_argv)
+          $PROGRAM_NAME = path
+          Uprb::RequireTracker.start
+          requires.each {|lib| require lib }
+          load path
+        rescue SystemExit => e
+        rescue StandardError => e
+          stdout_content = rewind_read_tempfile(tmp_stdout)
+          stderr_content = rewind_read_tempfile(tmp_stderr)
+          message = ["execution failed: #{e.class}: #{e.message}"]
+          message << "stdout: #{stdout_content}" unless stdout_content.empty?
+          message << "stderr: #{stderr_content}" unless stderr_content.empty?
+          raise Uprb::Error, message.join("\n")
+        ensure
+          mapping = Uprb::RequireTracker.stop
+          STDOUT.reopen(original_stdout)
+          STDERR.reopen(original_stderr)
+          ARGV.replace(original_argv)
+          $PROGRAM_NAME = original_program_name
+          tmp_stdout.close!
+          tmp_stderr.close!
+        end
+
+        mapping
+      end
+
+      def source_with_require_hook(source, requires = [])
+        preload_lines = requires.map {|lib| "require #{lib.inspect}" }.join("\n")
+        pre_code = <<~RUBY
+        module FixedRequire
+          SUFFIXES = #{Uprb::SUFFIXES.inspect}.freeze
+
+          def require(name)
+            entry = EMBEDDED_ISEQ[name]
+            if entry
+              path, binary = entry
+              return false if $LOADED_FEATURES.include?(path) || $LOADED_FEATURES.include?(name)
+              $LOADED_FEATURES << path
+              $LOADED_FEATURES << name unless $LOADED_FEATURES.include?(name)
+              mark_runtime_resolved(name, path)
+              RubyVM::InstructionSequence.load_from_binary(binary).eval
+              true
+            elsif (path = REQUIRE_MAP[name])
+              result = super(path)
+              mark_runtime_resolved(name, path) if result
+              result
+            else
+              super(name)
+            end
+          end
+
+          # C extensions bypass this hook via rb_require(); pre-mark the path
+          # $LOAD_PATH would resolve `name` to so they see it as already loaded.
+          def mark_runtime_resolved(name, loaded_path)
+            resolved = $LOAD_PATH.lazy.flat_map {|d| SUFFIXES.map {|s| File.join(d, "\#{name}\#{s}") } }.find {|p| File.file?(p) }
+            return unless resolved && resolved != loaded_path && !$LOADED_FEATURES.include?(resolved)
+            $LOADED_FEATURES << resolved
+          end
+        end
+
+        Kernel.prepend(FixedRequire)
+        #{preload_lines}
+        RUBY
+        pre_code + source
+      end
+
+      def build_payload(mapping)
+        embedded = {}
+        external = {}
+
+        mapping.each do |name, path|
+          if path.is_a?(String) && File.file?(path) && File.extname(path) == ".rb"
+            source = File.read(path)
+            iseq = RubyVM::InstructionSequence.compile(source, path, path)
+            embedded[name] = [path, iseq.to_binary]
+          else
+            external[name] = path
+          end
+        end
+
+        [embedded, external]
+      end
+    end
+  end
+end

data/lib/uprb/require_tracker.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Uprb
+  module RequireTracker
+    class << self
+      attr_reader :mapping
+
+      def start
+        install_require_hook
+        @mapping = {}
+      end
+
+      def stop
+        recorded = @mapping
+        @mapping = nil
+        return recorded
+      end
+
+      def record_require(name, features)
+        return if !@mapping || @mapping[name]
+
+        path = find_loaded_feature(name, features)
+        @mapping[name] = path if path
+      end
+
+      private
+
+      def install_require_hook
+        return if defined?(@require_hook_installed) && @require_hook_installed
+
+        if Kernel.private_method_defined?(:uprb_original_require)
+          @require_hook_installed = true
+          return
+        end
+
+        Kernel.module_eval do
+          alias_method :uprb_original_require, :require
+          alias_method :uprb_original_require_relative, :require_relative
+
+          def require(name)
+            before_size = $LOADED_FEATURES.size
+            required = uprb_original_require(name)
+            features = required ? $LOADED_FEATURES[before_size..] : $LOADED_FEATURES
+            Uprb::RequireTracker.record_require(name, features)
+            required
+          end
+
+          def require_relative(path)
+            caller_path = caller_locations(1, 1).first.path
+            absolute_path = File.expand_path(path, File.dirname(caller_path))
+            before_size = $LOADED_FEATURES.size
+            required = uprb_original_require(absolute_path)
+            features = required ? $LOADED_FEATURES[before_size..] : $LOADED_FEATURES
+            Uprb::RequireTracker.record_require(absolute_path, features)
+            required
+          end
+
+          private :require, :uprb_original_require
+          private :require_relative, :uprb_original_require_relative
+        end
+
+        @require_hook_installed = true
+      end
+
+      def find_loaded_feature(name, entries)
+        extname = File.extname(name)
+        if Uprb::SUFFIXES.include?(extname)
+          target_name = name.delete_suffix(extname)
+          suffixes = Uprb::DL_SUFFIXES.include?(extname) ? Uprb::DL_SUFFIXES : Uprb::SUFFIXES
+        else
+          target_name = name
+          suffixes = Uprb::SUFFIXES
+        end
+        suffixes.each do |suffix|
+          pattern = /(?:\A|#{File::SEPARATOR})#{target_name}#{suffix}\z/
+          # Ruby appends the parent after its nested children; search from the tail to hit it first.
+          entries.reverse_each do |f|
+            return f if pattern.match?(f)
+          end
+        end
+
+        nil
+      end
+
+      def absolute_path?(name)
+        name.start_with?(File::SEPARATOR) ||
+          (File::ALT_SEPARATOR && name.start_with?(File::ALT_SEPARATOR))
+      end
+    end
+  end
+end

data/lib/uprb/static_require_tracker.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require "prism"
+require "set"
+
+module Uprb
+  # Avoids running the entry's top-level code (CLI scripts often start
+  # `App.start(ARGV)` at load time) while still letting dependencies load
+  # normally so rubygems resolution, autoload registration, etc. happen.
+  module StaticRequireTracker
+    class << self
+      def trace(source_path, requires: [])
+        Tracer.new(requires: requires).trace(source_path)
+      end
+    end
+
+    class Tracer
+      def initialize(requires: [])
+        @requires = requires
+      end
+
+      def trace(source_path)
+        entry_path = File.expand_path(source_path)
+
+        dynamic = dynamic_phase(entry_path)
+        static = StaticWalker.new.walk(entry_path)
+
+        static.merge(dynamic)
+      end
+
+      private
+
+      def dynamic_phase(entry_path)
+        Uprb::RequireTracker.start
+        begin
+          @requires.each {|lib| require(lib) }
+          entry_dir = File.dirname(entry_path)
+          extract_requires(entry_path).each do |kind, name|
+            trigger(kind, name, entry_dir)
+          end
+        ensure
+          mapping = Uprb::RequireTracker.stop
+        end
+        mapping
+      end
+
+      def trigger(kind, name, entry_dir)
+        case kind
+        when :require
+          require(name)
+        when :require_relative
+          require(File.expand_path(name, entry_dir))
+        end
+      rescue LoadError
+        # The packed output falls through to runtime require for names we
+        # can't resolve here (e.g. local libs the entry would have added to
+        # $LOAD_PATH if it had been allowed to run).
+      end
+
+      def extract_requires(path)
+        source = File.read(path)
+        result = Prism.parse(source, filepath: path)
+        return [] if result.failure?
+
+        visitor = RequireVisitor.new
+        result.value.accept(visitor)
+        visitor.requires
+      end
+    end
+
+    class StaticWalker
+      def initialize
+        @mapping = {}
+        @visited = Set.new
+      end
+
+      def walk(entry_path)
+        parse_file(entry_path)
+        @mapping
+      end
+
+      private
+
+      def parse_file(path)
+        return unless @visited.add?(path)
+        return unless File.file?(path)
+
+        source = File.read(path)
+        result = Prism.parse(source, filepath: path)
+        return if result.failure?
+
+        visitor = RequireVisitor.new
+        result.value.accept(visitor)
+
+        visitor.requires.each do |kind, name|
+          case kind
+          when :require
+            record_require(name)
+          when :require_relative
+            absolute = File.expand_path(name, File.dirname(path))
+            resolved = resolve_file(absolute)
+            next unless resolved
+
+            @mapping[absolute] ||= resolved
+            parse_file(resolved) if resolved.end_with?(".rb")
+          end
+        end
+      end
+
+      def record_require(name)
+        resolved = resolve_in_load_path(name)
+        return unless resolved
+
+        @mapping[name] ||= resolved
+        parse_file(resolved) if resolved.end_with?(".rb")
+      end
+
+      # Skips rubygems' pre-activation steps (default-gem / unresolved-dep
+      # resolution) that run before the $LOAD_PATH search — so in environments
+      # with multi-version conflicts this may pick a different version than
+      # runtime would.
+      def resolve_in_load_path(name)
+        return resolve_file(name) if File.absolute_path?(name)
+
+        resolved = search_load_path(name)
+        return resolved if resolved
+
+        return nil unless defined?(Gem) && Gem.respond_to?(:try_activate)
+        return nil unless Gem.try_activate(name)
+
+        search_load_path(name)
+      end
+
+      def search_load_path(name)
+        $LOAD_PATH.each do |dir|
+          candidate = resolve_file(File.join(dir, name))
+          return candidate if candidate
+        end
+        nil
+      end
+
+      def resolve_file(path)
+        extname = File.extname(path)
+        if Uprb::SUFFIXES.include?(extname)
+          if Uprb::DL_SUFFIXES.include?(extname)
+            base = path.delete_suffix(extname)
+            Uprb::DL_SUFFIXES.each do |suffix|
+              candidate = "#{base}#{suffix}"
+              return candidate if File.file?(candidate)
+            end
+            nil
+          else
+            File.file?(path) ? path : nil
+          end
+        else
+          Uprb::SUFFIXES.each do |suffix|
+            candidate = "#{path}#{suffix}"
+            return candidate if File.file?(candidate)
+          end
+          nil
+        end
+      end
+    end
+
+    class RequireVisitor < Prism::Visitor
+      attr_reader :requires
+
+      def initialize
+        super
+        @requires = []
+      end
+
+      def visit_call_node(node)
+        case node.name
+        when :require, :require_relative
+          if node.receiver.nil?
+            name = extract_string_argument(node, index: 0)
+            @requires << [node.name, name] if name
+          end
+        when :autoload
+          name = extract_string_argument(node, index: 1)
+          @requires << [:require, name] if name
+        end
+        super
+      end
+
+      private
+
+      def extract_string_argument(node, index:)
+        args = node.arguments&.arguments
+        return nil unless args && args[index].is_a?(Prism::StringNode)
+
+        args[index].unescaped
+      end
+    end
+  end
+end

data/lib/uprb/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Uprb
+  VERSION = "0.1.0"
+end

data/lib/uprb.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "rbconfig"
+
+module Uprb
+  class Error < StandardError; end
+
+  DL_SUFFIXES = [".#{RbConfig::CONFIG['DLEXT']}", ".so", ".o"].uniq.freeze
+  SUFFIXES = ([".rb"] + DL_SUFFIXES).freeze
+end
+
+require_relative "uprb/version"
+require_relative "uprb/require_tracker"
+require_relative "uprb/static_require_tracker"
+require_relative "uprb/require_replacer"

data/sig/uprb.rbs

@@ -0,0 +1,4 @@
+module Uprb
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end