Merge pull request #22963 from danielfleischer/uv-bundle-source-option

Add source option to brew bundle uv tools

Author: MikeMcQuaid

Library/Homebrew/bundle/extensions/extension.rb

@@ -293,24 +293,7 @@ def self.package_installed?(name, with: nil)
       def self.preinstall!(name, with: nil, no_upgrade: false, verbose: false, **_options)
         _ = no_upgrade
 
-        unless package_manager_installed?
-          puts "Installing #{package_manager_name}. It is not currently installed." if verbose
-          Bundle.system(HOMEBREW_BREW_FILE, "install", "--formula", package_manager_name, verbose:)
-          # `formula_versions_from_env` consumes the env vars once at startup, so
-          # keep the cached values across reset when bootstrapping a manager.
-          formula_versions_from_env = T.let(
-            Bundle.formula_versions_from_env_cache,
-            T.nilable(T::Hash[String, String]),
-          )
-          upgrade_formulae = Bundle.upgrade_formulae
-          Bundle.reset!
-          Bundle.formula_versions_from_env_cache = formula_versions_from_env
-          Bundle.upgrade_formulae = upgrade_formulae.join(",")
-          unless package_manager_installed?
-            raise "Unable to install #{name} #{package_description}. " \
-                  "#{package_manager_name} installation failed."
-          end
-        end
+        ensure_package_manager_installed!(name, verbose:)
 
         if package_installed?(name, with:)
           puts "Skipping install of #{name} #{package_description}. It is already installed." if verbose
@@ -320,6 +303,28 @@ def self.preinstall!(name, with: nil, no_upgrade: false, verbose: false, **_opti
         true
       end
 
+      sig { params(name: String, verbose: T::Boolean).void }
+      def self.ensure_package_manager_installed!(name, verbose: false)
+        return if package_manager_installed?
+
+        puts "Installing #{package_manager_name}. It is not currently installed." if verbose
+        Bundle.system(HOMEBREW_BREW_FILE, "install", "--formula", package_manager_name, verbose:)
+        # `formula_versions_from_env` consumes the env vars once at startup, so
+        # keep the cached values across reset when bootstrapping a manager.
+        formula_versions_from_env = T.let(
+          Bundle.formula_versions_from_env_cache,
+          T.nilable(T::Hash[String, String]),
+        )
+        upgrade_formulae = Bundle.upgrade_formulae
+        Bundle.reset!
+        Bundle.formula_versions_from_env_cache = formula_versions_from_env
+        Bundle.upgrade_formulae = upgrade_formulae.join(",")
+        return if package_manager_installed?
+
+        raise "Unable to install #{name} #{package_description}. " \
+              "#{package_manager_name} installation failed."
+      end
+
       sig {
         override.params(
           name:       String,

Library/Homebrew/bundle/extensions/uv.rb

@@ -6,11 +6,13 @@
 module Homebrew
   module Bundle
     class Uv < Extension
-      WithOptions = T.type_alias { T::Hash[Symbol, T::Array[String]] }
-      Tool = T.type_alias { { name: String, with: T::Array[String] } }
+      WithOptions = T.type_alias { T::Hash[Symbol, T.any(String, T::Array[String])] }
+      Tool = T.type_alias { { name: String, with: T::Array[String], source: T.nilable(String) } }
       Checkable = T.type_alias { { name: String, options: WithOptions } }
       ToolEntry = T.type_alias { T.any(Tool, Checkable) }
 
+      SOURCE_REQUIREMENT_REGEX = T.let(%r{\A(?:git\+|https?://|file://|\.{0,2}/)|\.git\z}, Regexp)
+
       class << self
         sig { override.returns(Symbol) }
         def type = :uv
@@ -23,17 +25,24 @@ def banner_name = "uv tools"
 
         sig { override.params(name: String, options: Homebrew::Bundle::EntryInputOptions).returns(Dsl::Entry) }
         def entry(name, options = {})
-          unknown_options = options.keys - [:with]
+          unknown_options = options.keys - [:with, :source]
           raise "unknown options(#{unknown_options.inspect}) for uv" if unknown_options.present?
 
           with = options[:with]
           if !with.nil? && (!with.is_a?(Array) || with.any? { |requirement| !requirement.is_a?(String) })
             raise "options[:with](#{with.inspect}) should be an Array of String objects"
           end
 
+          source = options.fetch(:source, nil)
+          if !source.nil? && !source.is_a?(String)
+            raise "options[:source](#{source.inspect}) should be a String object"
+          end
+
           normalized_options = {}
           normalized_with = normalize_with(with || [])
           normalized_options[:with] = normalized_with if normalized_with.present?
+          normalized_source = normalize_source(source)
+          normalized_options[:source] = normalized_source if normalized_source.present?
 
           Dsl::Entry.new(:uv, name, normalized_options)
         end
@@ -55,7 +64,7 @@ def packages
           return packages if packages
 
           @packages = if (uv = package_manager_executable)
-            output = `#{uv} tool list --show-with --show-extras 2>/dev/null`
+            output = `#{uv} tool list --show-with --show-extras --show-version-specifiers 2>/dev/null`
             parse_tool_list(output)
           end
           return [] if @packages.nil?
@@ -73,17 +82,23 @@ def dump_with(package)
           package_with(T.cast(package, ToolEntry))
         end
 
+        sig { params(package: Object).returns(T.nilable(String)) }
+        def dump_source(package)
+          package_source(T.cast(package, ToolEntry))
+        end
+
         sig {
           override.params(
             name:    String,
             with:    T.nilable(T::Array[String]),
+            source:  T.nilable(String),
             verbose: T::Boolean,
           ).returns(T::Boolean)
         }
-        def install_package!(name, with: nil, verbose: false)
+        def install_package!(name, with: nil, source: nil, verbose: false)
           uv = package_manager_executable!
 
-          args = ["tool", "install", name]
+          args = ["tool", "install", source.presence || name]
           normalize_with(with || []).each do |requirement|
             args << "--with"
             args << requirement
@@ -114,17 +129,29 @@ def parse_tool_list(output)
             extras_raw = line[/\[extras:\s*([^\]]+)\]/, 1]
             name = name_with_extras(name, extras_raw)
             with_raw = line[/\[with:\s*([^\]]+)\]/, 1]
+            required_raw = line[/\[required:\s*([^\]]+)\]/, 1]
 
             entries << {
-              name: name,
-              with: parse_with_requirements(with_raw),
+              name:   name,
+              with:   parse_with_requirements(with_raw),
+              source: parse_source(required_raw),
             }
           end
 
           entries.sort_by { |entry| entry[:name].to_s }
         end
         private :parse_tool_list
 
+        sig { params(required_raw: T.nilable(String)).returns(T.nilable(String)) }
+        def parse_source(required_raw)
+          source = normalize_source(required_raw)
+          return if source.nil?
+          return source if source.match?(SOURCE_REQUIREMENT_REGEX)
+
+          nil
+        end
+        private :parse_source
+
         sig { params(name: String, extras_raw: T.nilable(String)).returns(String) }
         def name_with_extras(name, extras_raw)
           return name if extras_raw.blank?
@@ -175,6 +202,12 @@ def normalize_with(with)
         end
         private :normalize_with
 
+        sig { params(source: T.nilable(String)).returns(T.nilable(String)) }
+        def normalize_source(source)
+          source.presence&.strip
+        end
+        private :normalize_source
+
         sig { params(name: String).returns(String) }
         def normalize_name(name)
           match = name.strip.match(/\A(?<base>[^\[\]]+)(?:\[(?<extras>[^\]]+)\])?\z/)
@@ -193,16 +226,23 @@ def normalize_name(name)
         end
         private :normalize_name
 
-        sig { override.params(name: String, with: T.nilable(T::Array[String])).returns(Object) }
-        def package_record(name, with: nil)
-          normalized_options(name, with: with || [])
+        sig {
+          override.params(
+            name:   String,
+            with:   T.nilable(T::Array[String]),
+            source: T.nilable(String),
+          ).returns(Object)
+        }
+        def package_record(name, with: nil, source: nil)
+          normalized_options(name, with: with || [], source:)
         end
 
-        sig { params(name: String, with: T::Array[String]).returns(Tool) }
-        def normalized_options(name, with:)
+        sig { params(name: String, with: T::Array[String], source: T.nilable(String)).returns(Tool) }
+        def normalized_options(name, with:, source: nil)
           {
-            name: normalize_name(name),
-            with: normalize_with(with),
+            name:   normalize_name(name),
+            with:   normalize_with(with),
+            source: normalize_source(source),
           }
         end
         private :normalized_options
@@ -223,6 +263,85 @@ def package_with(package)
         end
         private :package_with
 
+        sig { params(package: ToolEntry).returns(T.nilable(String)) }
+        def package_source(package)
+          return package[:source] if package.key?(:source)
+
+          T.cast(package[:options].fetch(:source, nil), T.nilable(String))
+        end
+        private :package_source
+
+        sig { override.params(package: Object).returns(String) }
+        def dump_entry(package)
+          line = super
+          source = dump_source(package)
+          line = "#{line}, source: #{quote(source)}" if source.present?
+
+          line
+        end
+
+        sig {
+          override.params(
+            name:       String,
+            with:       T.nilable(T::Array[String]),
+            source:     T.nilable(String),
+            no_upgrade: T::Boolean,
+            verbose:    T::Boolean,
+            _options:   Homebrew::Bundle::EntryOption,
+          ).returns(T::Boolean)
+        }
+        def preinstall!(name, with: nil, source: nil, no_upgrade: false, verbose: false, **_options)
+          _ = no_upgrade
+
+          ensure_package_manager_installed!(name, verbose:)
+
+          if package_installed?(name, with:, source:)
+            puts "Skipping install of #{name} #{package_description}. It is already installed." if verbose
+            return false
+          end
+
+          true
+        end
+
+        sig {
+          override.params(
+            name:       String,
+            with:       T.nilable(T::Array[String]),
+            source:     T.nilable(String),
+            preinstall: T::Boolean,
+            no_upgrade: T::Boolean,
+            verbose:    T::Boolean,
+            force:      T::Boolean,
+            _options:   Homebrew::Bundle::EntryOption,
+          ).returns(T::Boolean)
+        }
+        def install!(name, with: nil, source: nil, preinstall: true, no_upgrade: false, verbose: false, force: false,
+                     **_options)
+          _ = no_upgrade
+          _ = force
+
+          return true unless preinstall
+
+          puts "Installing #{name} #{package_description}. It is not currently installed." if verbose
+          return false unless install_package!(name, with:, source:, verbose:)
+
+          package = normalized_options(name, with: with || [], source:)
+          installed_packages << package unless installed_packages.include?(package)
+          packages << package unless packages.include?(package)
+          true
+        end
+
+        sig {
+          override.params(
+            name:   String,
+            with:   T.nilable(T::Array[String]),
+            source: T.nilable(String),
+          ).returns(T::Boolean)
+        }
+        def package_installed?(name, with: nil, source: nil)
+          installed_packages.include?(package_record(name, with:, source:))
+        end
+
         sig { override.params(name: String, executable: Pathname).void }
         def uninstall_package!(name, executable: Pathname.new(""))
           Bundle.system(executable.to_s, "tool", "uninstall", name, verbose: false)
@@ -232,16 +351,18 @@ def uninstall_package!(name, executable: Pathname.new(""))
       sig { override.params(entries: T::Array[Dsl::Entry]).returns(T::Array[Object]) }
       def format_checkable(entries)
         checkable_entries(entries).map do |entry|
-          with = if entry.options.is_a?(Hash)
-            value = entry.options[:with]
-            value.is_a?(Array) ? value : []
-          else
-            []
-          end
-
-          self.class.package_record(entry.name, with:)
+          { name: entry.name, options: entry.options }
         end
       end
+
+      sig { override.params(package: Object, no_upgrade: T::Boolean).returns(T::Boolean) }
+      def installed_and_up_to_date?(package, no_upgrade: false)
+        self.class.package_installed?(
+          self.class.dump_name(package),
+          with:   self.class.dump_with(package),
+          source: self.class.dump_source(package),
+        )
+      end
     end
   end
 end

Library/Homebrew/test/bundle/dsl_spec.rb

@@ -119,6 +119,11 @@ def dsl_from_string(string)
       expect(dsl.entries[0].name).to eql("mkdocs")
       expect(dsl.entries[0].options).to eql(with: ["mkdocs-material<10"])
     end
+
+    it "accepts a uv source option" do
+      dsl = dsl_from_string 'uv "ruff", source: "git+https://github.com/astral-sh/ruff.git"'
+      expect(dsl.entries[0].options).to eql(source: "git+https://github.com/astral-sh/ruff.git")
+    end
   end
 
   context "with invalid input" do
@@ -158,6 +163,15 @@ def dsl_from_string(string)
       end.to raise_error(RuntimeError, /options\[:with\].*Array of String objects/)
     end
 
+    it "errors on invalid uv source options" do
+      expect do
+        dsl_from_string 'uv "ruff", source: 123'
+      end.to raise_error(RuntimeError, /options\[:source\].*String object/)
+      expect do
+        dsl_from_string 'uv "ruff", branch: "main"'
+      end.to raise_error(RuntimeError, /unknown options\(\[:branch\]\) for uv/)
+    end
+
     it "errors on invalid winget options" do
       expect do
         dsl_from_string 'winget "PowerToys", id: 123'