RTECO-1536 - Add native RubyGems/Bundler command with auth and build-info

artifactory/commands/ruby/ruby.go

@@ -3,22 +3,43 @@ package ruby
 import (
 	"net/url"
 
+	buildUtils "github.com/jfrog/jfrog-cli-core/v2/common/build"
 	"github.com/jfrog/jfrog-cli-core/v2/utils/config"
 	"github.com/jfrog/jfrog-client-go/auth"
 	"github.com/jfrog/jfrog-client-go/utils/errorutils"
 )
 
+// RubyCommand runs a native RubyGems (`gem`) or Bundler (`bundle`) command directly,
+// injecting Artifactory authentication and optionally collecting build info.
+//
+// It is a config-less native flow (like `jf uv`): the server is resolved from
+// --server-id or the default server, and the Artifactory repository is discovered
+// from the project's own Ruby configuration (Gemfile source, .bundle/config,
+// gem sources). The `.jfrog/projects/ruby.yaml` produced by `jf ruby-config` is NOT
+// read by this command.
 type RubyCommand struct {
 	serverDetails *config.ServerDetails
-	commandName   string
-	args          []string
-	repository    string
+	// nativeTool is the underlying binary to run: "gem" or "bundle".
+	nativeTool string
+	// args are the arguments passed to the native tool, including its sub-command
+	// (e.g. ["install", "--without", "test"]).
+	args []string
+	// serverID is the explicit --server-id, empty for the default server.
+	serverID string
+	// repository optionally overrides the Artifactory repo (otherwise auto-discovered).
+	repository         string
+	buildConfiguration *buildUtils.BuildConfiguration
 }
 
 func NewRubyCommand() *RubyCommand {
 	return &RubyCommand{}
 }
 
+func (rc *RubyCommand) SetNativeTool(tool string) *RubyCommand {
+	rc.nativeTool = tool
+	return rc
+}
+
 func (rc *RubyCommand) SetRepo(repo string) *RubyCommand {
 	rc.repository = repo
 	return rc
@@ -29,8 +50,13 @@ func (rc *RubyCommand) SetArgs(arguments []string) *RubyCommand {
 	return rc
 }
 
-func (rc *RubyCommand) SetCommandName(commandName string) *RubyCommand {
-	rc.commandName = commandName
+func (rc *RubyCommand) SetServerID(serverID string) *RubyCommand {
+	rc.serverID = serverID
+	return rc
+}
+
+func (rc *RubyCommand) SetBuildConfiguration(bc *buildUtils.BuildConfiguration) *RubyCommand {
+	rc.buildConfiguration = bc
 	return rc
 }
 
@@ -40,7 +66,15 @@ func (rc *RubyCommand) SetServerDetails(serverDetails *config.ServerDetails) *Ru
 }
 
 func (rc *RubyCommand) ServerDetails() (*config.ServerDetails, error) {
-	return rc.serverDetails, nil
+	if rc.serverDetails != nil {
+		return rc.serverDetails, nil
+	}
+	return rubyResolveServerDetails(rc.serverID)
+}
+
+// CommandName is the usage-report metric id for native Ruby commands.
+func (rc *RubyCommand) CommandName() string {
+	return "rt_ruby_native"
 }
 
 // GetRubyGemsRepoUrlWithCredentials gets the RubyGems repository url and the credentials.

artifactory/commands/setup/setup.go

@@ -18,6 +18,7 @@ import (
 	container "github.com/jfrog/jfrog-cli-artifactory/artifactory/commands/ocicontainer"
 	"github.com/jfrog/jfrog-cli-artifactory/artifactory/commands/python"
 	"github.com/jfrog/jfrog-cli-artifactory/artifactory/commands/repository"
+	"github.com/jfrog/jfrog-cli-artifactory/artifactory/commands/ruby"
 	commandsutils "github.com/jfrog/jfrog-cli-core/v2/artifactory/commands/utils"
 	"github.com/jfrog/jfrog-cli-core/v2/artifactory/utils"
 	"github.com/jfrog/jfrog-cli-core/v2/artifactory/utils/maven"
@@ -31,6 +32,7 @@ import (
 	"github.com/jfrog/jfrog-client-go/utils/errorutils"
 	"github.com/jfrog/jfrog-client-go/utils/log"
 	"golang.org/x/exp/maps"
+	"gopkg.in/yaml.v3"
 )
 
 // packageManagerToRepositoryPackageType maps project types to corresponding Artifactory repository package types.
@@ -61,6 +63,8 @@ var packageManagerToRepositoryPackageType = map[project.ProjectType]string{
 
 	project.Gradle: repository.Gradle,
 	project.Maven:  repository.Maven,
+
+	project.Ruby: repository.Gems,
 }
 
 // SetupCommand configures registries and authentication for various package manager (npm, Yarn, Pip, Pipenv, Poetry, UV, Go)
@@ -184,6 +188,8 @@ func (sc *SetupCommand) Run() (err error) {
 		err = sc.configureMaven()
 	case project.UV:
 		err = sc.configureUV()
+	case project.Ruby:
+		err = sc.configureRuby()
 	default:
 		err = errorutils.CheckErrorf("unsupported package manager: %s", sc.packageManager)
 	}
@@ -570,6 +576,150 @@ func (sc *SetupCommand) configureUV() error {
 	return nil
 }
 
+// rubygemsDefaultSource is the default source RubyGems ships with; when present in
+// ~/.gemrc's :sources: list, it is always kept first.
+const rubygemsDefaultSource = "https://rubygems.org"
+
+// configureRuby configures RubyGems and Bundler to use Artifactory as a gem source.
+// It performs:
+//  1. Writes per-host Bundler credentials directly to ~/.bundle/config
+//  2. Adds the Artifactory source to ~/.gemrc, or prints guidance for Gemfile
+//
+// Both gem and bundle tools will then authenticate to the Artifactory gems repository.
+func (sc *SetupCommand) configureRuby() error {
+	repoUrl, username, password, err := ruby.GetRubyGemsRepoUrlWithCredentials(sc.serverDetails, sc.repoName)
+	if err != nil {
+		return fmt.Errorf("failed to get RubyGems repository URL with credentials: %w", err)
+	}
+
+	// If no credentials are provided, just print guidance.
+	if username == "" && password == "" {
+		log.Output(fmt.Sprintf("Add this source to your Gemfile:\n  source \"%s\"\n", repoUrl.String()))
+		return nil
+	}
+
+	host := repoUrl.Hostname()
+	if repoUrl.Port() != "" {
+		host += ":" + repoUrl.Port()
+	}
+
+	if bundleErr := writeBundleConfig(host, username, password); bundleErr != nil {
+		return fmt.Errorf("failed to configure Bundler credentials: %w", bundleErr)
+	}
+	log.Info(fmt.Sprintf("Bundler configured: credentials set for host '%s'", host))
+
+	// Configure gem: add source to ~/.gemrc.
+	sourceURL := repoUrl.String()
+	if gemrcErr := addGemrcSource(sourceURL); gemrcErr != nil {
+		return fmt.Errorf("failed to update ~/.gemrc: %w", gemrcErr)
+	}
+
+	log.Output(fmt.Sprintf("\nAdd this source to your Gemfile:\n  source \"%s\"\n", sourceURL))
+	return nil
+}
+
+// writeBundleConfig writes per-host Bundler credentials directly to ~/.bundle/config,
+// bypassing the `bundle config` CLI entirely (its `set` subcommand doesn't exist on
+// Bundler 1.x). The config key is derived via ruby.BundleEnvKeyForHost, the same
+// normalization `jf ruby bundle install` uses at runtime, so setup-time and
+// runtime-injection key formats can never drift apart.
+func writeBundleConfig(host, user, password string) error {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return err
+	}
+	bundleDir := home + "/.bundle"
+	configPath := bundleDir + "/config"
+
+	existing, readErr := os.ReadFile(configPath)
+	if readErr != nil && !os.IsNotExist(readErr) {
+		return readErr
+	}
+
+	config := map[string]interface{}{}
+	if len(existing) > 0 {
+		if unmarshalErr := yaml.Unmarshal(existing, &config); unmarshalErr != nil {
+			return fmt.Errorf("parse existing %s: %w", configPath, unmarshalErr)
+		}
+	}
+
+	config[ruby.BundleEnvKeyForHost(host)] = user + ":" + password
+
+	out, marshalErr := yaml.Marshal(config)
+	if marshalErr != nil {
+		return marshalErr
+	}
+	if mkdirErr := os.MkdirAll(bundleDir, 0755); mkdirErr != nil {
+		return mkdirErr
+	}
+	return os.WriteFile(configPath, out, 0600)
+}
+
+// addGemrcSource adds sourceURL to ~/.gemrc's :sources: list. An exact-match existing
+// entry is moved to the front (behind rubygemsDefaultSource, if present) rather than
+// duplicated; a new entry is prepended. Different repos configured across multiple runs
+// are meant to coexist here, since gem install natively searches every listed source.
+func addGemrcSource(sourceURL string) error {
+	home, err := os.UserHomeDir()
+	if err != nil {
+		return err
+	}
+	gemrcPath := home + "/.gemrc"
+
+	existing, readErr := os.ReadFile(gemrcPath)
+	if readErr != nil && !os.IsNotExist(readErr) {
+		return readErr
+	}
+
+	config := map[string]interface{}{}
+	if len(existing) > 0 {
+		if unmarshalErr := yaml.Unmarshal(existing, &config); unmarshalErr != nil {
+			return fmt.Errorf("parse existing %s: %w", gemrcPath, unmarshalErr)
+		}
+	}
+
+	var currentSources []string
+	if raw, ok := config[":sources"]; ok {
+		if rawList, ok := raw.([]interface{}); ok {
+			for _, item := range rawList {
+				if s, ok := item.(string); ok {
+					currentSources = append(currentSources, s)
+				}
+			}
+		}
+	} else {
+		currentSources = []string{rubygemsDefaultSource}
+	}
+
+	config[":sources"] = reorderGemrcSources(currentSources, sourceURL)
+
+	out, marshalErr := yaml.Marshal(config)
+	if marshalErr != nil {
+		return marshalErr
+	}
+	return os.WriteFile(gemrcPath, out, 0644)
+}
+
+// reorderGemrcSources returns sources with sourceURL moved to the front (deduplicated if
+// already present), keeping rubygemsDefaultSource first when it's in the list.
+func reorderGemrcSources(sources []string, sourceURL string) []string {
+	hasDefault := slices.Contains(sources, rubygemsDefaultSource)
+
+	result := make([]string, 0, len(sources)+1)
+	if hasDefault {
+		result = append(result, rubygemsDefaultSource)
+	}
+	result = append(result, sourceURL)
+
+	for _, s := range sources {
+		if s == rubygemsDefaultSource || s == sourceURL {
+			continue
+		}
+		result = append(result, s)
+	}
+	return result
+}
+
 // configureHelm configures Helm to use Artifactory as an OCI registry.
 // It executes:
 //