Remove special-casing of MacOS::languages.

Library/Homebrew/cask/auditor.rb

@@ -49,18 +49,16 @@ module Cask
     private
 
     def audit_all_languages
-      saved_languages = MacOS.instance_variable_get(:@languages)
+      language_blocks.keys.all?(&method(:audit_languages))
-      begin
-        language_blocks.keys.all?(&method(:audit_languages))
-      ensure
-        MacOS.instance_variable_set(:@languages, saved_languages)
-      end
     end
 
     def audit_languages(languages)
       ohai "Auditing language: #{languages.map { |lang| "'#{lang}'" }.to_sentence}"
-      MacOS.instance_variable_set(:@languages, languages)
+      localized_cask = CaskLoader.load(cask.sourcefile_path)
-      audit_cask_instance(CaskLoader.load(cask.sourcefile_path))
+      config = localized_cask.config
+      config.languages = languages
+      localized_cask.config = config
+      audit_cask_instance(localized_cask)
     end
 
     def audit_cask_instance(cask)

Library/Homebrew/cask/cmd.rb

@@ -65,8 +65,7 @@ module Cask
 
     option "--help", :help, false
 
-    # handled in OS::Mac
+    option "--language=a,b,c", ->(value) { Config.global.languages = value }
-    option "--language a,b,c", ->(*) {}
 
     # override default handling of --version
     option "--version", ->(*) { raise OptionParser::InvalidOption }
@@ -180,8 +179,6 @@ module Cask
     end
 
     def process_options(*args)
-      exclude_regex = /^--#{Regexp.union(*Config::DEFAULT_DIRS.keys.map(&Regexp.public_method(:escape)))}=/
-
       non_options = []
 
       if idx = args.index("--")
@@ -189,15 +186,32 @@ module Cask
         args = args.first(idx)
       end
 
+      exclude_regex = /^--#{Regexp.union(*Config::DEFAULT_DIRS.keys.map(&Regexp.public_method(:escape)))}=/
       cask_opts = Shellwords.shellsplit(ENV.fetch("HOMEBREW_CASK_OPTS", ""))
                             .reject { |arg| arg.match?(exclude_regex) }
 
       all_args = cask_opts + args
 
-      remaining = all_args.select do |arg|
+      i = 0
-        !process_arguments([arg]).empty?
+      remaining = []
-      rescue OptionParser::InvalidOption, OptionParser::MissingArgument, OptionParser::AmbiguousOption
+
-        true
+      while i < all_args.count
+        begin
+          arg = all_args[i]
+          next if process_arguments([arg]).empty?
+
+          remaining << arg
+        rescue OptionParser::MissingArgument
+          raise if i + 1 >= all_args.count
+
+          args = all_args[i..(i + 1)]
+          process_arguments(args)
+          i += 1
+        rescue OptionParser::InvalidOption
+          remaining << arg
+        end
+
+        i += 1
       end
 
       remaining + non_options

Library/Homebrew/cask/config.rb

@@ -2,6 +2,9 @@
 
 require "json"
 
+require "lazy_object"
+require "locale"
+
 require "extend/hash_validator"
 using HashValidator
 
@@ -24,6 +27,12 @@ module Cask
       screen_saverdir:      "~/Library/Screen Savers",
     }.freeze
 
+    def self.defaults
+      {
+        languages: LazyObject.new { MacOS.languages },
+      }.merge(DEFAULT_DIRS).freeze
+    end
+
     def self.global
       @global ||= new
     end
@@ -69,16 +78,16 @@ module Cask
     attr_accessor :explicit
 
     def initialize(default: nil, env: nil, explicit: {})
-      @default = self.class.canonicalize(DEFAULT_DIRS.merge(default)) if default
+      @default = self.class.canonicalize(self.class.defaults.merge(default)) if default
       @env = self.class.canonicalize(env) if env
       @explicit = self.class.canonicalize(explicit)
 
-      @env&.assert_valid_keys!(*DEFAULT_DIRS.keys)
+      @env&.assert_valid_keys!(*self.class.defaults.keys)
-      @explicit.assert_valid_keys!(*DEFAULT_DIRS.keys)
+      @explicit.assert_valid_keys!(*self.class.defaults.keys)
     end
 
     def default
-      @default ||= self.class.canonicalize(DEFAULT_DIRS)
+      @default ||= self.class.canonicalize(self.class.defaults)
     end
 
     def env
@@ -86,7 +95,16 @@ module Cask
         Shellwords.shellsplit(ENV.fetch("HOMEBREW_CASK_OPTS", ""))
                   .select { |arg| arg.include?("=") }
                   .map { |arg| arg.split("=", 2) }
-                  .map { |(flag, value)| [flag.sub(/^--/, ""), value] },
+                  .map do |(flag, value)|
+                    key = flag.sub(/^--/, "")
+
+                    if key == "language"
+                      key = "languages"
+                      value = value.split(",")
+                    end
+
+                    [key, value]
+                  end,
       )
     end
 
@@ -98,6 +116,24 @@ module Cask
       @manpagedir ||= HOMEBREW_PREFIX/"share/man"
     end
 
+    def languages
+      [
+        *explicit[:languages],
+        *env[:languages],
+        *default[:languages],
+      ].uniq.select do |lang|
+        # Ensure all languages are valid.
+        Locale.parse(lang)
+        true
+      rescue Locale::ParserError
+        false
+      end
+    end
+
+    def languages=(languages)
+      explicit[:languages] = languages
+    end
+
     DEFAULT_DIRS.each_key do |dir|
       define_method(dir) do
         explicit.fetch(dir, env.fetch(dir, default.fetch(dir)))

Library/Homebrew/cask/dsl.rb

@@ -137,13 +137,13 @@ module Cask
 
       raise CaskInvalidError.new(cask, "No default language specified.") if @language_blocks.default.nil?
 
-      locales = MacOS.languages
+      locales = cask.config.languages
-                     .map do |language|
+                    .map do |language|
-                       Locale.parse(language)
+        Locale.parse(language)
-                     rescue Locale::ParserError
+      rescue Locale::ParserError
-                       nil
+        nil
-                     end
+      end
-                     .compact
+                    .compact
 
       locales.each do |locale|
         key = locale.detect(@language_blocks.keys)
@@ -225,7 +225,7 @@ module Cask
     end
 
     def caskroom_path
-      @cask.caskroom_path
+      cask.caskroom_path
     end
 
     def staged_path

Library/Homebrew/os/mac.rb

@@ -68,21 +68,7 @@ module OS
       end
       os_langs = os_langs.scan(/[^ \n"(),]+/)
 
-      @languages = [
+      @languages = os_langs
-        *Homebrew.args.value("language")&.split(","),
-        *ENV["HOMEBREW_LANGUAGES"]&.split(","),
-        *os_langs,
-      ].uniq
-
-      # Ensure all languages are valid
-      @languages.select! do |lang|
-        Locale.parse(lang)
-        true
-      rescue Locale::ParserError
-        false
-      end
-
-      @languages
     end
 
     def language

Library/Homebrew/test/cask/dsl_spec.rb

@@ -118,8 +118,8 @@ describe Cask::DSL, :cask do
   end
 
   describe "language stanza" do
-    it "allows multilingual casks" do
+    context "when language is set explicitly" do
-      cask = lambda do
+      subject(:cask) {
         Cask::Cask.new("cask-with-apps") do
           language "zh" do
             sha256 "abc123"
@@ -133,37 +133,65 @@ describe Cask::DSL, :cask do
 
           url "https://example.org/#{language}.zip"
         end
+      }
+
+      matcher :be_the_chinese_version do
+        match do |cask|
+          expect(cask.language).to eq("zh-CN")
+          expect(cask.sha256).to eq("abc123")
+          expect(cask.url.to_s).to eq("https://example.org/zh-CN.zip")
+        end
       end
 
-      allow(MacOS).to receive(:languages).and_return(["zh"])
+      matcher :be_the_english_version do
-      expect(cask.call.language).to eq("zh-CN")
+        match do |cask|
-      expect(cask.call.sha256).to eq("abc123")
+          expect(cask.language).to eq("en-US")
-      expect(cask.call.url.to_s).to eq("https://example.org/zh-CN.zip")
+          expect(cask.sha256).to eq("xyz789")
+          expect(cask.url.to_s).to eq("https://example.org/en-US.zip")
+        end
+      end
 
-      allow(MacOS).to receive(:languages).and_return(["zh-XX"])
+      before do
-      expect(cask.call.language).to eq("zh-CN")
+        config = cask.config
-      expect(cask.call.sha256).to eq("abc123")
+        config.languages = languages
-      expect(cask.call.url.to_s).to eq("https://example.org/zh-CN.zip")
+        cask.config = config
+      end
 
-      allow(MacOS).to receive(:languages).and_return(["en"])
+      context "to 'zh'" do
-      expect(cask.call.language).to eq("en-US")
+        let(:languages) { ["zh"] }
-      expect(cask.call.sha256).to eq("xyz789")
-      expect(cask.call.url.to_s).to eq("https://example.org/en-US.zip")
 
-      allow(MacOS).to receive(:languages).and_return(["xx-XX"])
+        it { is_expected.to be_the_chinese_version }
-      expect(cask.call.language).to eq("en-US")
+      end
-      expect(cask.call.sha256).to eq("xyz789")
-      expect(cask.call.url.to_s).to eq("https://example.org/en-US.zip")
 
-      allow(MacOS).to receive(:languages).and_return(["xx-XX", "zh", "en"])
+      context "to 'zh-XX'" do
-      expect(cask.call.language).to eq("zh-CN")
+        let(:languages) { ["zh-XX"] }
-      expect(cask.call.sha256).to eq("abc123")
-      expect(cask.call.url.to_s).to eq("https://example.org/zh-CN.zip")
 
-      allow(MacOS).to receive(:languages).and_return(["xx-XX", "en-US", "zh"])
+        it { is_expected.to be_the_chinese_version }
-      expect(cask.call.language).to eq("en-US")
+      end
-      expect(cask.call.sha256).to eq("xyz789")
+
-      expect(cask.call.url.to_s).to eq("https://example.org/en-US.zip")
+      context "to 'en'" do
+        let(:languages) { ["en"] }
+
+        it { is_expected.to be_the_english_version }
+      end
+
+      context "to 'xx-XX'" do
+        let(:languages) { ["xx-XX"] }
+
+        it { is_expected.to be_the_english_version }
+      end
+
+      context "to 'xx-XX,zh,en'" do
+        let(:languages) { ["xx-XX", "zh", "en"] }
+
+        it { is_expected.to be_the_chinese_version }
+      end
+
+      context "to 'xx-XX,en-US,zh'" do
+        let(:languages) { ["xx-XX", "en-US", "zh"] }
+
+        it { is_expected.to be_the_english_version }
+      end
     end
 
     it "returns an empty array if no languages are specified" do