traveling-ruby 0.1.0

data/lib/traveling_ruby/release.rb

@@ -0,0 +1,136 @@
+require "json"
+require "set"
+
+module TravelingRuby
+  # One Ruby version and revision of Traveling Ruby, published as a release per
+  # target tagged ruby-<ruby>-<revision>-<target>. Each release has the runtime,
+  # a tarball per native gem, SHA256SUMS and manifest.json.
+  #
+  # The source is a GitHub repository URL, or a local directory holding a
+  # directory per release tag (handy for mirrors and testing).
+  class Release
+    DEFAULT_SOURCE = "https://github.com/trubygems/traveling-ruby".freeze
+
+    attr_reader :ruby, :revision
+
+    def self.resolve(fetcher:, source: DEFAULT_SOURCE, ruby: nil, revision: nil)
+      source = source.chomp("/")
+      if ruby.nil?
+        raise Error, "set the Ruby version to use a local source" if fetcher.local?(source)
+        tag = fetcher.redirect_location("#{source}/releases/latest").to_s.split("/").last
+        match = tag.to_s.match(/\Aruby-([^-]+)-(\d+)-/)
+        raise Error, "could not find the latest release at #{source}; set the Ruby version" unless match
+        ruby = match[1]
+        revision ||= match[2]
+      end
+      revision ||= newest_revision(fetcher, source, ruby)
+      new(fetcher: fetcher, source: source, ruby: ruby, revision: revision.to_s)
+    end
+
+    # From versions/RUBY_REVISIONS.txt, one "<ruby> <revision>" per line
+    def self.newest_revision(fetcher, source, ruby)
+      url =
+        if fetcher.local?(source)
+          File.join(source, "RUBY_REVISIONS.txt")
+        elsif (repo = source[%r{\Ahttps://github\.com/([^/]+/[^/]+)\z}, 1])
+          "https://raw.githubusercontent.com/#{repo}/main/versions/RUBY_REVISIONS.txt"
+        end
+      revisions = url && fetcher.read(url)
+      line = revisions.to_s.lines.map(&:split).find { |version, _| version == ruby }
+      line ? line[1] : "0"
+    end
+
+    def initialize(fetcher:, source:, ruby:, revision:)
+      @fetcher = fetcher
+      @source = source
+      @ruby = ruby
+      @revision = revision
+      @checksums = {}
+      @manifests = {}
+    end
+
+    def to_s
+      "#{ruby}-#{revision}"
+    end
+
+    def key(target)
+      "#{ruby}-#{revision}-#{target}"
+    end
+
+    def tag(target)
+      "ruby-#{key(target)}"
+    end
+
+    # The runtime tarball, downloaded and verified. The full runtime keeps what
+    # the slim one leaves out, such as Ruby's headers and static libraries.
+    def runtime(target, full: false)
+      file =
+        if full
+          manifest(target).dig("runtime_full", "file") || "traveling-ruby-#{key(target)}-full.tar.gz"
+        else
+          manifest(target).dig("runtime", "file") || "traveling-ruby-#{key(target)}.tar.gz"
+        end
+      fetch(target, file)
+    end
+
+    # Full names (name-version) of the gems the runtime comes with: Ruby's
+    # default and bundled gems
+    def runtime_gems(target, full: false)
+      @runtime_gems ||= {}
+      @runtime_gems[[target, full]] ||= begin
+        listing = IO.popen(["tar", "-tzf", runtime(target, full: full)], &:read)
+        raise Error, "could not list #{File.basename(runtime(target, full: full))}" unless $?.success?
+        listing.scan(%r{/specifications/(?:default/)?([^/\n]+)\.gemspec$}).flatten.to_set
+      end
+    end
+
+    # Native gems built for target, as {name, version, file, sha256}
+    def gems(target)
+      manifest(target).fetch("gems", [])
+    end
+
+    # Versions of a native gem built for target
+    def built_versions(target, name)
+      gems(target).select { |gem| gem["name"] == name }.map { |gem| gem["version"] }
+    end
+
+    # The tarball of a native gem's extension, or nil when it was not built
+    def gem_extension(target, name, version)
+      gem = gems(target).find { |g| g["name"] == name && g["version"] == version }
+      gem && fetch(target, gem["file"])
+    end
+
+    def manifest(target)
+      @manifests[target] ||= begin
+        body = @fetcher.read(url(target, "manifest.json"))
+        raise Error, "no Traveling Ruby #{self} release for #{target} (#{url(target, "manifest.json")} not found)" unless body
+        JSON.parse(body)
+      end
+    end
+
+    private
+
+    def fetch(target, file)
+      sha256 = checksums(target)[file] or raise Error, "#{file} is not listed in #{tag(target)}'s SHA256SUMS"
+      @fetcher.fetch(url(target, file), sha256: sha256, cache_key: File.join(tag(target), file))
+    end
+
+    def checksums(target)
+      @checksums[target] ||= begin
+        body = @fetcher.read(url(target, "SHA256SUMS")) or raise Error, "#{tag(target)} has no SHA256SUMS"
+        body.lines.to_h do |line|
+          sha256, file = line.strip.split(/ [ *]/, 2)
+          [file, sha256]
+        end
+      end
+    end
+
+    def url(target, file)
+      if @fetcher.local?(@source)
+        File.join(@source, tag(target), file)
+      else
+        "#{@source}/releases/download/#{tag(target)}/#{file}"
+      end
+    end
+  end
+end

data/lib/traveling_ruby/ui.rb

@@ -0,0 +1,78 @@
+module TravelingRuby
+  # Terminal output: colored when the stream is a terminal and NO_COLOR is not
+  # set, plain otherwise (CI logs, pipes, tests)
+  class UI
+    COLORS = {red: 31, green: 32, yellow: 33, cyan: 36, bold: 1, dim: 2}.freeze
+
+    attr_reader :io
+
+    def initialize(io = $stderr, verbose: false, color: nil)
+      @io = io
+      @verbose = verbose
+      @color = color.nil? ? io.respond_to?(:tty?) && io.tty? && ENV["NO_COLOR"].to_s.empty? : color
+    end
+
+    def verbose?
+      @verbose
+    end
+
+    def say(message = "")
+      @io.puts message
+    end
+
+    def title(message)
+      say paint(message, :bold)
+    end
+
+    # A finished step: "  ✓ label  detail"
+    def done(label, detail = nil)
+      say "  #{paint("✓", :green)} #{label}#{"  #{paint(detail, :dim)}" if detail}"
+    end
+
+    def failed(label, detail = nil)
+      say "  #{paint("✗", :red)} #{label}#{"  #{detail}" if detail}"
+    end
+
+    def hint(message)
+      say "      #{paint("→ #{message}", :cyan)}"
+    end
+
+    def warn(message)
+      say "#{paint("warning:", :yellow, :bold)} #{message}"
+    end
+
+    def error(message)
+      say "#{paint("error:", :red, :bold)} #{message}"
+    end
+
+    # Shown with --verbose only
+    def detail(message)
+      say paint("    #{message}", :dim) if @verbose
+    end
+
+    # Downloads are worth seeing: they explain a slow first run
+    def fetching(what)
+      say paint("  ↓ #{what}", :dim)
+    end
+
+    def paint(text, *styles)
+      return text.to_s unless @color
+      "\e[#{styles.map { |style| COLORS.fetch(style) }.join(";")}m#{text}\e[0m"
+    end
+
+    def self.size(bytes)
+      units = %w[B KB MB GB]
+      value = bytes.to_f
+      unit = units.shift
+      while value >= 1024 && units.any?
+        value /= 1024
+        unit = units.shift
+      end
+      unit == "B" ? "#{bytes} B" : format("%.1f %s", value, unit)
+    end
+
+    def self.duration(seconds)
+      seconds < 60 ? format("%.1fs", seconds) : format("%dm %ds", seconds / 60, seconds % 60)
+    end
+  end
+end

data/lib/traveling_ruby/version.rb

@@ -0,0 +1,3 @@
+module TravelingRuby
+  VERSION = "0.1.0"
+end

data/lib/traveling_ruby.rb

@@ -0,0 +1,31 @@
+$LOAD_PATH.unshift(__dir__) unless $LOAD_PATH.include?(__dir__)
+
+require "traveling_ruby/version"
+
+module TravelingRuby
+  class Error < StandardError; end
+
+  # Targets that have a release, as named in release tags
+  TARGETS = %w[
+    linux-x86_64 linux-arm64
+    linux-musl-x86_64 linux-musl-arm64
+    macos-x86_64 macos-arm64
+    windows-x86_64 windows-arm64
+  ].freeze
+
+  # Packaged when no targets are given
+  DEFAULT_TARGETS = %w[linux-x86_64 linux-arm64 macos-x86_64 macos-arm64 windows-x86_64].freeze
+
+  def self.windows?(target)
+    target.start_with?("windows-")
+  end
+
+  autoload :UI, "traveling_ruby/ui"
+  autoload :Config, "traveling_ruby/config"
+  autoload :Fetcher, "traveling_ruby/fetcher"
+  autoload :Release, "traveling_ruby/release"
+  autoload :Bundle, "traveling_ruby/bundle"
+  autoload :Launcher, "traveling_ruby/launcher"
+  autoload :Packager, "traveling_ruby/packager"
+  autoload :CLI, "traveling_ruby/cli"
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: traveling-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Yousaf Nabi
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Builds self-contained packages of a Ruby app for each platform Traveling Ruby
+  supports: the app, its gems, the prebuilt native extensions they need and a
+  portable Ruby, behind a launcher script. No Ruby is needed to run them.
+executables:
+- traveling-ruby
+- truby
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- exe/traveling-ruby
+- exe/truby
+- lib/traveling_ruby.rb
+- lib/traveling_ruby/bundle.rb
+- lib/traveling_ruby/cli.rb
+- lib/traveling_ruby/config.rb
+- lib/traveling_ruby/fetcher.rb
+- lib/traveling_ruby/launcher.rb
+- lib/traveling_ruby/packager.rb
+- lib/traveling_ruby/rake_task.rb
+- lib/traveling_ruby/release.rb
+- lib/traveling_ruby/ui.rb
+- lib/traveling_ruby/version.rb
+homepage: https://github.com/trubygems/traveling-ruby
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/trubygems/traveling-ruby/tree/main/packager
+  bug_tracker_uri: https://github.com/trubygems/traveling-ruby/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: 'truby: package Ruby apps to run on Linux, macOS and Windows with no Ruby
+  installed'
+test_files: []