tuxedo-r 0.0.1-x86_64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 90745a96bbaed4ba7faea66a1ed059a77bf1964abbd8e77317e8a97ea79460bc
+  data.tar.gz: 7ced61877adc8267bd4aeeb16002256b451ca6bf63b23bed6f2fdd9116eefb67
+SHA512:
+  metadata.gz: dbb893e1d2fd9e130829d8ee1e00131e3d5f28de6d22333c0180373fa3aaee457cfc0e11e14ca1e38186547e3f72bc5c17b11fd76797c12f7475aa1c9678f338
+  data.tar.gz: 2115df0cb3626d183d562fceaab0c0b966777fed1e511a95c181758aa52d3184fe5542da94befa79425d325877bfdc81227f4d9edfe4766c0de4263b92648789

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Danimar Ribeiro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,82 @@
+# tuxedo-r
+
+[Tuxedo](https://github.com/danimaribeiro/tuxedo) is a fast Ruby code
+formatter written in Rust. `tuxedo-r` is the Ruby gem that installs it: each
+platform-specific gem carries a precompiled native binary, so no Rust
+toolchain is needed. The name is deliberately ambiguous: the "R" stands for
+both **Ruby** (the language it formats, and the language of this wrapper) and
+**Rust** (the language the `tuxedo` binary itself is written in).
+
+## Installation
+
+```ruby
+group :development, :test do
+  gem "tuxedo-r", require: false
+end
+```
+
+```bash
+bundle install
+bundle exec tuxedo format --check .
+```
+
+Without Bundler:
+
+```bash
+gem install tuxedo-r
+tuxedo format .
+```
+
+RubyGems automatically resolves and installs the platform-specific gem that
+matches your machine (for example `tuxedo-r-x86_64-linux`). This release
+ships a precompiled binary for x86_64 Linux (glibc) only; on any other
+platform, see [Unsupported platforms](#unsupported-platforms). The
+[documentation](https://danimar.dev/tuxedo/docs.html) covers what
+the formatter does, its command line and its configuration.
+
+### Requirements
+
+Ruby 3.1 or newer and RubyGems 3.3.22 or newer (`gem update --system`).
+`required_ruby_version` is the Ruby that runs the `tuxedo` shim, not the
+Ruby syntax `tuxedo` accepts. On Alpine and other musl hosts, RubyGems
+older than 3.3.22 resolves the glibc gem, whose binary will not run.
+
+### Unsupported platforms
+
+If a precompiled binary isn't available for your platform yet, set
+`TUXEDO_INSTALL_DIR` to a directory containing a `tuxedo` executable (for
+example, one you built yourself from the
+[Rust crate](https://github.com/danimaribeiro/tuxedo)):
+
+```bash
+export TUXEDO_INSTALL_DIR=/path/to/tuxedo/target/release
+bundle exec tuxedo format --check .
+```
+
+## How it works
+
+- The `tuxedo-r` gem itself ships no binary — it's the platform-independent
+  "meta" gem.
+- `tuxedo-r-<platform>` gems (built by `rake package`, see
+  [`rakelib/package.rake`](https://github.com/danimaribeiro/tuxedo/blob/main/ruby/rakelib/package.rake))
+  each bundle a `tuxedo` binary compiled for that target triple, under
+  `exe/<platform>/tuxedo`.
+- The `exe/tuxedo` script installed onto your `PATH` is plain Ruby (RubyGems
+  requires gem executables to be Ruby scripts) — it just finds the right
+  binary for the current platform and `exec`s it, forwarding all arguments and
+  the exit status.
+
+## Development
+
+```bash
+cd ruby
+bundle install
+bundle exec rake test
+
+# Build the tuxedo binary for every supported platform (requires `cross`
+# for cross-compiled targets: cargo install cross)
+bundle exec rake build:all
+
+# Package all platform gems into pkg/
+bundle exec rake package
+```

data/exe/tuxedo

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# RubyGems executable shims assume a gem's executables are Ruby scripts, so
+# this file exists purely to locate and exec the real, compiled `tuxedo`
+# binary for the current platform.
+
+require "tuxedo/r"
+
+begin
+  command = [Tuxedo::R.executable, *ARGV]
+  if Gem.win_platform?
+    # `exec` can fail to locate the binary on Windows; `system` is more reliable there.
+    system(*command, exception: true)
+  else
+    exec(*command)
+  end
+rescue Tuxedo::R::UnsupportedPlatformException, Tuxedo::R::ExecutableNotFoundException => e
+  warn "ERROR: #{e.message}"
+  exit 1
+end

data/lib/tuxedo/r/native_platforms.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Tuxedo
+  module R
+    module NativePlatforms
+      # rubygems platform name => rust target triple
+      #
+      # Keep this in sync with the build matrix in
+      # tuxedo/.github/workflows/release.yml
+      TARGETS = {
+        "arm64-darwin" => "aarch64-apple-darwin",
+        "x86_64-darwin" => "x86_64-apple-darwin",
+        "x86_64-linux" => "x86_64-unknown-linux-gnu",
+        "aarch64-linux" => "aarch64-unknown-linux-gnu",
+        "x86_64-linux-musl" => "x86_64-unknown-linux-musl",
+        "aarch64-linux-musl" => "aarch64-unknown-linux-musl",
+        "x64-mingw-ucrt" => "x86_64-pc-windows-msvc",
+      }.freeze
+
+      def self.binary_name(platform)
+        platform.to_s.include?("mingw") ? "tuxedo.exe" : "tuxedo"
+      end
+    end
+  end
+end

data/lib/tuxedo/r/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Tuxedo
+  module R
+    VERSION = "0.0.1"
+  end
+end

data/lib/tuxedo/r.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require_relative "r/version"
+require_relative "r/native_platforms"
+
+module Tuxedo
+  # The "R" is deliberately ambiguous: this is the Ruby wrapper around a
+  # Rust-compiled `tuxedo` binary.
+  module R
+    DEFAULT_DIR = File.expand_path(File.join(__dir__, "..", "..", "exe"))
+    GEM_NAME = "tuxedo-r"
+
+    # Raised when the host platform has no precompiled tuxedo binary published.
+    class UnsupportedPlatformException < StandardError
+    end
+
+    # Raised when the tuxedo executable could not be found where expected.
+    class ExecutableNotFoundException < StandardError
+    end
+
+    # Raised when TUXEDO_INSTALL_DIR is set but does not exist.
+    class DirectoryNotFoundException < StandardError
+    end
+
+    class << self
+      # e.g. "x86_64-linux"; on Alpine, `version` carries the musl
+      # distinction, without which this would misname the host.
+      def platform
+        [:cpu, :os, :version].map { |m| Gem::Platform.local.send(m) }.compact.join("-")
+      end
+
+      # Absolute path to the tuxedo binary that should be executed on this host.
+      #
+      # Resolution order:
+      #   1. TUXEDO_INSTALL_DIR env var, if set (escape hatch for local dev / CI
+      #      builds that want to use a freshly-built binary instead of the one
+      #      vendored into the installed platform gem).
+      #   2. The platform-specific binary bundled into the matching
+      #      tuxedo-r-<platform> gem.
+      def executable(exe_path: DEFAULT_DIR)
+        tuxedo_install_dir = ENV["TUXEDO_INSTALL_DIR"]
+
+        if tuxedo_install_dir
+          unless File.directory?(tuxedo_install_dir)
+            raise DirectoryNotFoundException, <<~MESSAGE
+              TUXEDO_INSTALL_DIR is set to #{tuxedo_install_dir}, but that directory does not exist.
+            MESSAGE
+          end
+
+          warn "NOTE: using TUXEDO_INSTALL_DIR to find the tuxedo executable: #{tuxedo_install_dir}"
+          exe_file = File.expand_path(File.join(tuxedo_install_dir, "tuxedo"))
+        else
+          if NativePlatforms::TARGETS.keys.none? { |p| Gem::Platform.match_gem?(Gem::Platform.new(p), GEM_NAME) }
+            raise UnsupportedPlatformException, <<~MESSAGE
+              #{GEM_NAME} does not have a precompiled binary for the #{platform} platform.
+              See https://github.com/danimaribeiro/tuxedo/tree/main/ruby#unsupported-platforms for options.
+            MESSAGE
+          end
+
+          exe_file = Dir.glob(File.expand_path(File.join(exe_path, "*", "tuxedo{,.exe}"))).find do |f|
+            Gem::Platform.match_gem?(Gem::Platform.new(File.basename(File.dirname(f))), GEM_NAME)
+          end
+        end
+
+        if exe_file.nil? || !File.exist?(exe_file)
+          raise ExecutableNotFoundException, <<~MESSAGE
+            Cannot find the tuxedo executable for #{platform} in #{exe_path}.
+
+            If you're using Bundler, make sure your lockfile includes this platform:
+
+                bundle lock --add-platform #{platform}
+                bundle install
+
+            If you're still seeing this after that, check whether
+            `bundle config force_ruby_platform` is set to `true`.
+
+            This version of #{GEM_NAME} may not ship a binary for #{platform} at all; see
+            https://github.com/danimaribeiro/tuxedo/tree/main/ruby#unsupported-platforms for options.
+          MESSAGE
+        end
+
+        exe_file
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: tuxedo-r
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: x86_64-linux
+authors:
+- Danimar Ribeiro
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-09-24 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Tuxedo is a Ruby code formatter written in Rust, distributed as a
+  precompiled native binary wrapped in this Ruby gem (the "R" is both Ruby and
+  Rust). It is `bundle exec`-compatible, and a linter is planned.
+email:
+executables:
+- tuxedo
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- exe/tuxedo
+- exe/x86_64-linux/tuxedo
+- lib/tuxedo/r.rb
+- lib/tuxedo/r/native_platforms.rb
+- lib/tuxedo/r/version.rb
+homepage: https://github.com/danimaribeiro/tuxedo
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://danimar.dev/tuxedo/docs.html
+  source_code_uri: https://github.com/danimaribeiro/tuxedo
+  changelog_uri: https://github.com/danimaribeiro/tuxedo/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.22
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: 'A self-contained `tuxedo` executable: a fast Ruby formatter written in Rust.'
+test_files: []