kabosu 0.6.10.2-aarch64-linux → 0.6.11.2-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 577865838ed4b3c8e4dcac92bf4c804681afeae5cd69f022c3b9118564048ca3
-  data.tar.gz: e1aeeb28f258bfbbc798e719b6f3fe6fa67617b429bea721c8370722ceacb832
+  metadata.gz: 6310222bef7890fd2ae5882d39f312a656d2bbfbb115d41a9dff80ac94b11932
+  data.tar.gz: f6d831203d5a58c208f7fee1b21f0036b9d0c344fc16652f8cf1e5fe7ef38e46
 SHA512:
-  metadata.gz: dbcae83cab2c261b499ccd648f1917b02853866b40e63ecc728a6480dfd8c8055b55550d6a65d3c04edc98d1f38b4b0320bb6917169bb3caef44aa04306f7f77
-  data.tar.gz: d5d67d2f5e4d8fd86e202b96851f94731a7841c239744ea7d168d73be9f1d0e1d5c01fff6b79849dd809304bd1fd62c12accab1a7c9c26dc45c3b0f36367453c
+  metadata.gz: f945a86f63e3694fb8bb4a199dbb83470977ed77f1e0d0ae41f66482986e9ff4d9acf148affb77e7e7a4487f512924f54884f92d0155d85cb0787494dd9d825f
+  data.tar.gz: 3a85e6084607c95ff81d0a1807813c625b1a4d9d84ae28c21626ae97d8b501b1a38131306cd38b8cd2939d1fb0e8acbe763cb415c9cb7fc80c44d5a027b775fc

data/lib/kabosu/dict_manager.rb

@@ -8,8 +8,8 @@ module Kabosu
   class DictManager
     EDITIONS = %w[small core full].freeze
     EDITION_PRIORITY = %w[full core small].freeze
-    GITHUB_REPO = "WorksApplications/SudachiDict"
-    GITHUB_API = "https://api.github.com"
+    GITHUB_REPO = "WorksApplications/SudachiDict".freeze
+    GITHUB_API = "https://api.github.com".freeze
 
     class DictNotFound < StandardError; end
     class DownloadError < StandardError; end
@@ -42,23 +42,40 @@ module Kabosu
       dic_path = File.join(dest_dir, "system_#{edition}.dic")
 
       if File.exist?(dic_path)
-        $stderr.puts "Already installed: #{dic_path}"
+        warn "Already installed: #{dic_path}"
         return dic_path
       end
 
-      url = release_asset_url(version, edition)
-      zip_path = File.join(@dir, "sudachi-dictionary-#{version}-#{edition}.zip")
-
       FileUtils.mkdir_p(@dir)
-      download(url, zip_path)
-      extract(zip_path, @dir)
-      FileUtils.rm_f(zip_path)
 
-      unless File.exist?(dic_path)
-        raise DownloadError, "Expected #{dic_path} after extraction, but file not found"
+      # SudachiDict switched to Python-only release assets in v20260723:
+      # https://github.com/WorksApplications/SudachiDict/releases/tag/v20260723
+      # The legacy `sudachi-dictionary-{version}-{edition}.zip` is gone; the
+      # new releases ship `sudachidict_{edition}-{version}-py3-none-any.whl`
+      # (a PEP 427 wheel). Pick whichever exists, preferring the legacy zip
+      # when both are present (older releases kept both formats in flight).
+      sources = pick_release_sources(version, edition)
+      raise DownloadError, "No downloadable assets for #{version}/#{edition}" if sources.empty?
+
+      sources.each do |source|
+        begin
+          download(source.fetch(:url), source.fetch(:archive_path))
+          extract(source.fetch(:archive_path), dest_dir, edition: edition)
+          FileUtils.rm_f(source.fetch(:archive_path))
+          break
+        rescue DownloadError => e
+          FileUtils.rm_f(source.fetch(:archive_path)) if File.exist?(source.fetch(:archive_path))
+          # Try the next candidate (e.g. wheel if the zip 404s). If this was
+          # the last one, surface the original error.
+          raise if sources.last.equal?(source)
+
+          warn "  falling back: #{e.message}"
+        end
       end
 
-      $stderr.puts "Installed: #{dic_path}"
+      raise DownloadError, "Expected #{dic_path} after extraction, but file not found" unless File.exist?(dic_path)
+
+      warn "Installed: #{dic_path}"
       dic_path
     end
 
@@ -88,7 +105,7 @@ module Kabosu
       results = []
       return results unless Dir.exist?(@dir)
 
-      Dir.glob(File.join(@dir, "sudachi-dictionary-*")).sort.reverse.each do |version_dir|
+      Dir.glob(File.join(@dir, "sudachi-dictionary-*")).reverse.each do |version_dir|
         next unless File.directory?(version_dir)
 
         version = File.basename(version_dir).sub("sudachi-dictionary-", "")
@@ -113,6 +130,7 @@ module Kabosu
         edition = validate_edition(edition)
         match = candidates.find { |d| d[:edition] == edition }
         raise DictNotFound, "No #{edition} dictionary installed" unless match
+
         return match[:path]
       end
 
@@ -140,14 +158,14 @@ module Kabosu
 
       targets.each do |d|
         FileUtils.rm_f(d[:path])
-        $stderr.puts "Removed: #{d[:path]}"
+        warn "Removed: #{d[:path]}"
 
         # Clean up empty version directories
         version_dir = File.dirname(d[:path])
         dics_remaining = Dir.glob(File.join(version_dir, "system_*.dic"))
         if dics_remaining.empty?
           FileUtils.rm_rf(version_dir)
-          $stderr.puts "Removed empty directory: #{version_dir}"
+          warn "Removed empty directory: #{version_dir}"
         end
       end
     end
@@ -178,15 +196,61 @@ module Kabosu
       unless EDITIONS.include?(edition)
         raise ArgumentError, "Unknown edition '#{edition}'. Must be one of: #{EDITIONS.join(", ")}"
       end
+
       edition
     end
 
+    # Look up the GitHub release for `version` and return an ordered list of
+    # candidate download sources. The legacy `sudachi-dictionary-{version}-{edition}.zip`
+    # is preferred when present (matches the layout every other consumer
+    # assumes); otherwise we fall back to the SudachiDict Python wheel,
+    # which is what v20260723+ ship and which carries `system.dic` inside
+    # `sudachidict_{edition}/resources/`.
+    #
+    # On GitHub API failure we degrade to the legacy zip URL alone: an old
+    # release that 404s on the zip *also* 404s on the wheel, so falling back
+    # to "guessed" candidates costs nothing and keeps the code path simple
+    # for offline / no-network callers.
+    def pick_release_sources(version, edition)
+      candidates = []
+      zip = release_asset_url(version, edition)
+      candidates << { url: zip, archive_path: File.join(@dir, "sudachi-dictionary-#{version}-#{edition}.zip"), format: :zip }
+
+      begin
+        release = fetch_release(version)
+        if release
+          wheel_name = "sudachidict_#{edition}-#{version}-py3-none-any.whl"
+          wheel = release["assets"].to_a.find { |a| a["name"] == wheel_name }
+          if wheel && wheel["browser_download_url"]
+            candidates << {
+              url: wheel.fetch("browser_download_url"),
+              archive_path: File.join(@dir, wheel_name),
+              format: :wheel
+            }
+          end
+        end
+      rescue DownloadError
+        # API failure is fine: keep the legacy-zip candidate; the user will
+        # see a clean 404 if neither asset actually exists on disk.
+      end
+
+      candidates
+    end
+
+    def fetch_release(version)
+      uri = URI("#{GITHUB_API}/repos/#{GITHUB_REPO}/releases/tags/v#{version}")
+      response = http_get(uri, headers: { "Accept" => "application/json" })
+      return nil unless response.is_a?(Net::HTTPSuccess)
+
+      JSON.parse(response.body)
+    end
+
     def release_asset_url(version, edition)
       "https://github.com/#{GITHUB_REPO}/releases/download/v#{version}/sudachi-dictionary-#{version}-#{edition}.zip"
     end
 
     def download(url, dest)
-      $stderr.puts "Downloading #{url}..."
+      warn "Downloading #{url}..."
       uri = resolve_redirects(URI(url))
 
       Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
@@ -202,20 +266,22 @@ module Kabosu
             response.read_body do |chunk|
               f.write(chunk)
               written += chunk.bytesize
-              if total && total > 0
+              if total&.positive?
                 pct = (written * 100 / total).clamp(0, 100)
-                $stderr.print "\r  #{(written.to_f / 1024 / 1024).round(1)} / #{(total.to_f / 1024 / 1024).round(1)} MB (#{pct}%)"
+                done_mb = (written.to_f / 1024 / 1024).round(1)
+                total_mb = (total.to_f / 1024 / 1024).round(1)
+                $stderr.print "\r  #{done_mb} / #{total_mb} MB (#{pct}%)"
               end
             end
           end
 
-          $stderr.puts "\r  #{(written.to_f / 1024 / 1024).round(1)} MB downloaded"
+          warn "\r  #{(written.to_f / 1024 / 1024).round(1)} MB downloaded"
         end
       end
     end
 
     def resolve_redirects(uri, limit: 5)
-      raise DownloadError, "Too many redirects" if limit == 0
+      raise DownloadError, "Too many redirects" if limit.zero?
 
       Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
         response = http.request(Net::HTTP::Head.new(uri))
@@ -229,7 +295,7 @@ module Kabosu
     end
 
     def http_get(uri, headers: {}, redirect_limit: 5)
-      raise DownloadError, "Too many redirects" if redirect_limit == 0
+      raise DownloadError, "Too many redirects" if redirect_limit.zero?
 
       http = Net::HTTP.new(uri.host, uri.port)
       http.use_ssl = (uri.scheme == "https")
@@ -247,15 +313,27 @@ module Kabosu
       end
     end
 
-    def extract(zip_path, dest_dir)
-      $stderr.puts "Extracting..."
+    def extract(zip_path, dest_dir, edition: nil)
+      warn "Extracting..."
       Zip::File.open(zip_path) do |archive|
         archive.each do |entry|
-          target = File.join(dest_dir, entry.name)
+          # Wheels (`sudachidict_{edition}/resources/system.dic`) carry the
+          # edition in the top-level directory; legacy zips name the file
+          # `system_{edition}.dic` already. When the entry is a `system.dic`
+          # inside a wheel and `edition:` was passed, land it at
+          # `dest_dir/system_{edition}.dic` so `find`/`installed` keep working
+          # without a separate code path.
+          target_name = entry.name
+          if edition && File.basename(entry.name) == "system.dic"
+            target_name = "system_#{edition}.dic"
+          end
+
+          target = File.join(dest_dir, target_name)
           # Guard against zip-slip — refuse entries that escape dest_dir.
           unless File.expand_path(target).start_with?(File.expand_path(dest_dir) + File::SEPARATOR)
             raise DownloadError, "Refusing to extract entry outside dest_dir: #{entry.name}"
           end
+
           FileUtils.mkdir_p(File.dirname(target))
           entry.extract(target) { true } # overwrite existing
         end

data/lib/kabosu/morpheme_list.rb

@@ -7,7 +7,7 @@ module Kabosu
     def initialize(source_or_morphemes, internal_cost: nil)
       @source = source_or_morphemes if lazy_source?(source_or_morphemes)
       @morphemes = @source ? Array.new(@source.size) : source_or_morphemes
-      @internal_cost = internal_cost || (@source&.internal_cost)
+      @internal_cost = internal_cost || @source&.internal_cost
     end
 
     def each(&block)
@@ -62,7 +62,7 @@ module Kabosu
     end
 
     def surfaces
-      return @source.surfaces if @source&.respond_to?(:surfaces)
+      return @source.surfaces if @source.respond_to?(:surfaces)
 
       map(&:surface)
     end
@@ -96,9 +96,7 @@ module Kabosu
     # source. Falls back to a Ruby implementation for already-materialized
     # lists so the method is always safe to call.
     def group_morphemes
-      if @source&.respond_to?(:group_morphemes)
-        return @source.group_morphemes
-      end
+      return @source.group_morphemes if @source.respond_to?(:group_morphemes)
 
       groups = []
       each do |m|
@@ -131,10 +129,12 @@ module Kabosu
 
     def clause_boundary?(morpheme)
       return false unless morpheme
+
       pos = morpheme.part_of_speech
       return true if pos[0] == "助詞" &&
                      %w[ながら たら ば と のに から ので けれど けど つつ なり や か かどうか とも].include?(morpheme.surface)
       return true if pos[0] == "助詞" && pos[1] == "接続助詞" && morpheme.surface == "が"
+
       false
     end
 

data/lib/kabosu/pos_matcher.rb

@@ -48,13 +48,15 @@ module Kabosu
 
     # Union: matches if either matcher matches.
     def |(other)
-      a, b = self, other
+      a = self
+      b = other
       PosMatcher.new { |pos| a.match?(pos) || b.match?(pos) }
     end
 
     # Intersection: matches if both matchers match.
     def &(other)
-      a, b = self, other
+      a = self
+      b = other
       PosMatcher.new { |pos| a.match?(pos) && b.match?(pos) }
     end
 
@@ -64,7 +66,8 @@ module Kabosu
     end
 
     def difference(other)
-      a, b = self, other
+      a = self
+      b = other
       PosMatcher.new { |pos| a.match?(pos) && !b.match?(pos) }
     end
 
@@ -95,7 +98,7 @@ module Kabosu
     end
 
     def self.proper_nouns
-      @proper_nouns ||= new(["名詞", "固有名詞"])
+      @proper_nouns ||= new(%w[名詞 固有名詞])
     end
 
     private

data/lib/kabosu/tasks.rake

@@ -5,53 +5,54 @@ namespace :kabosu do
 
   desc "Install the core dictionary (default). VERSION=YYYYMMDD to pin a specific release."
   task :install do
-    Kabosu::DictManager.new.install("core", version: ENV["VERSION"])
+    Kabosu::DictManager.new.install("core", version: ENV.fetch("VERSION", nil))
   end
 
   namespace :install do
     desc "Install the small dictionary. VERSION=YYYYMMDD to pin a specific release."
     task :small do
-      Kabosu::DictManager.new.install("small", version: ENV["VERSION"])
+      Kabosu::DictManager.new.install("small", version: ENV.fetch("VERSION", nil))
     end
 
     desc "Install the core dictionary. VERSION=YYYYMMDD to pin a specific release."
     task :core do
-      Kabosu::DictManager.new.install("core", version: ENV["VERSION"])
+      Kabosu::DictManager.new.install("core", version: ENV.fetch("VERSION", nil))
     end
 
     desc "Install the full dictionary. VERSION=YYYYMMDD to pin a specific release."
     task :full do
-      Kabosu::DictManager.new.install("full", version: ENV["VERSION"])
+      Kabosu::DictManager.new.install("full", version: ENV.fetch("VERSION", nil))
     end
   end
 
-  desc "Install a dictionary only if a matching one isn't already on disk. EDITION=core|small|full (default core), VERSION=YYYYMMDD optional."
+  desc "Install a dictionary only if a matching one isn't already on disk. " \
+       "EDITION=core|small|full (default core), VERSION=YYYYMMDD optional."
   task :install_if_missing do
     edition = ENV["EDITION"] || "core"
-    Kabosu::DictManager.new.install_if_missing(edition, version: ENV["VERSION"])
+    Kabosu::DictManager.new.install_if_missing(edition, version: ENV.fetch("VERSION", nil))
   end
 
   # ── Remove ──
 
   desc "Remove all installed dictionaries, or a specific one with EDITION=small|core|full and/or VERSION=YYYYMMDD"
   task :remove do
-    Kabosu::DictManager.new.remove(edition: ENV["EDITION"], version: ENV["VERSION"])
+    Kabosu::DictManager.new.remove(edition: ENV.fetch("EDITION", nil), version: ENV.fetch("VERSION", nil))
   end
 
   namespace :remove do
     desc "Remove the small dictionary."
     task :small do
-      Kabosu::DictManager.new.remove(edition: "small", version: ENV["VERSION"])
+      Kabosu::DictManager.new.remove(edition: "small", version: ENV.fetch("VERSION", nil))
     end
 
     desc "Remove the core dictionary."
     task :core do
-      Kabosu::DictManager.new.remove(edition: "core", version: ENV["VERSION"])
+      Kabosu::DictManager.new.remove(edition: "core", version: ENV.fetch("VERSION", nil))
     end
 
     desc "Remove the full dictionary."
     task :full do
-      Kabosu::DictManager.new.remove(edition: "full", version: ENV["VERSION"])
+      Kabosu::DictManager.new.remove(edition: "full", version: ENV.fetch("VERSION", nil))
     end
   end
 
@@ -82,11 +83,9 @@ namespace :kabosu do
 
   desc "Show the path to the best available dictionary. EDITION=small|core|full to be specific."
   task :path do
-    begin
-      puts Kabosu::DictManager.new.find(edition: ENV["EDITION"])
-    rescue Kabosu::DictManager::DictNotFound => e
-      $stderr.puts e.message
-      exit 1
-    end
+    puts Kabosu::DictManager.new.find(edition: ENV.fetch("EDITION", nil))
+  rescue Kabosu::DictManager::DictNotFound => e
+    warn e.message
+    exit 1
   end
 end

data/lib/kabosu/version.rb

@@ -1,3 +1,3 @@
 module Kabosu
-  VERSION = "0.6.10.2"
+  VERSION = "0.6.11.2".freeze
 end

data/lib/kabosu.rb

@@ -66,25 +66,17 @@ module Kabosu
     DEFAULT_CONFIG_PATH = File.expand_path("kabosu/resources/sudachi.json", __dir__).freeze
 
     class << self
-      alias_method :_new, :new
+      alias _new new
 
       def new(config: nil, system_dict: nil, user_dicts: nil)
-        unless config.nil? || config.is_a?(String)
-          raise ArgumentError, "config must be a String or nil"
-        end
-        unless system_dict.nil? || system_dict.is_a?(String)
-          raise ArgumentError, "system_dict must be a String or nil"
-        end
+        raise ArgumentError, "config must be a String or nil" unless config.nil? || config.is_a?(String)
+        raise ArgumentError, "system_dict must be a String or nil" unless system_dict.nil? || system_dict.is_a?(String)
         unless user_dicts.nil? || user_dicts.is_a?(Array)
           raise ArgumentError, "user_dicts must be an Array<String> or nil"
         end
-        if user_dicts&.any? { !_1.is_a?(String) }
-          raise ArgumentError, "user_dicts must contain only String values"
-        end
+        raise ArgumentError, "user_dicts must contain only String values" if user_dicts&.any? { !_1.is_a?(String) }
 
-        if config.nil? && system_dict.nil?
-          raise ArgumentError, "either config or system_dict is required"
-        end
+        raise ArgumentError, "either config or system_dict is required" if config.nil? && system_dict.nil?
 
         # Default to the sudachi.json bundled with this gem when only
         # system_dict is given. sudachi.rs's own default config path is
@@ -113,9 +105,7 @@ module Kabosu
 
       def map_dictionary_init_error(error, config:, system_dict:)
         message = error.message
-        if config && system_dict.nil?
-          ConfigError.new(message)
-        elsif message.match?(/config|setting\.json|json/i)
+        if (config && system_dict.nil?) || message.match?(/config|setting\.json|json/i)
           ConfigError.new(message)
         else
           DictionaryError.new(message)
@@ -127,40 +117,33 @@ module Kabosu
       end
     end
 
-    alias_method :_create, :create
-    alias_method :_lookup, :lookup
+    alias _create create
+    alias _lookup lookup
 
     def create(**options)
       unknown = options.keys - %i[mode fields debug projection]
-      raise ArgumentError, "unknown keyword(s): #{unknown.join(', ')}" unless unknown.empty?
+      raise ArgumentError, "unknown keyword(s): #{unknown.join(", ")}" unless unknown.empty?
 
       mode = options.fetch(:mode, MODE_C)
       fields = options.fetch(:fields, nil)
       debug = options.fetch(:debug, false)
       projection = options.fetch(:projection, nil)
 
-      unless fields.nil? || fields.is_a?(Array)
-        raise ArgumentError, "fields must be an Array<String|Symbol> or nil"
-      end
+      raise ArgumentError, "fields must be an Array<String|Symbol> or nil" unless fields.nil? || fields.is_a?(Array)
       if fields&.any? { !(_1.is_a?(String) || _1.is_a?(Symbol)) }
         raise ArgumentError, "fields must contain only String or Symbol values"
       end
-      unless debug == true || debug == false
-        raise ArgumentError, "debug must be true or false"
-      end
+      raise ArgumentError, "debug must be true or false" unless [true, false].include?(debug)
 
-      unless projection.nil?
-        raise NotImplementedError, "projection is not supported yet"
-      end
+      raise NotImplementedError, "projection is not supported yet" unless projection.nil?
 
       mode_str = Kabosu.__send__(:normalize_mode, mode)
       _create(mode_str, fields, debug)
     end
 
     def lookup(text)
-      unless text.is_a?(String)
-        raise ArgumentError, "text must be a String"
-      end
+      raise ArgumentError, "text must be a String" unless text.is_a?(String)
+
       MorphemeList.new(_lookup(text))
     rescue RuntimeError => e
       raise LookupError.new(e.message), cause: e
@@ -170,12 +153,10 @@ module Kabosu
   # ── Tokenizer: wrap output in MorphemeList ──
 
   class Tokenizer
-    alias_method :_tokenize, :tokenize
+    alias _tokenize tokenize
 
     def tokenize(text)
-      unless text.is_a?(String)
-        raise ArgumentError, "text must be a String"
-      end
+      raise ArgumentError, "text must be a String" unless text.is_a?(String)
 
       batch = _tokenize(text)
       cost = batch.respond_to?(:internal_cost) ? batch.internal_cost : nil
@@ -186,12 +167,11 @@ module Kabosu
   end
 
   class Morpheme
-    alias_method :_split, :split
+    alias _split split
 
     def split(mode: MODE_C, add_single: true)
-      unless add_single == true || add_single == false
-        raise ArgumentError, "add_single must be true or false"
-      end
+      raise ArgumentError, "add_single must be true or false" unless [true, false].include?(add_single)
+
       mode_str = Kabosu.__send__(:normalize_mode, mode)
       MorphemeList.new(_split(mode_str, nil, add_single))
     rescue RuntimeError => e
@@ -200,29 +180,15 @@ module Kabosu
   end
 
   def self.split_sentences(text, limit: nil, with_checker: false, ranges: false, dictionary: nil)
-    unless text.is_a?(String)
-      raise ArgumentError, "text must be a String"
-    end
-    unless limit.nil? || limit.is_a?(Integer)
-      raise ArgumentError, "limit must be an Integer or nil"
-    end
-    if limit && limit < 1
-      raise ArgumentError, "limit must be greater than 0"
-    end
-    unless with_checker == true || with_checker == false
-      raise ArgumentError, "with_checker must be true or false"
-    end
-    unless ranges == true || ranges == false
-      raise ArgumentError, "ranges must be true or false"
-    end
-    unless dictionary.nil? || dictionary.is_a?(String)
-      raise ArgumentError, "dictionary must be a String path or nil"
-    end
+    raise ArgumentError, "text must be a String" unless text.is_a?(String)
+    raise ArgumentError, "limit must be an Integer or nil" unless limit.nil? || limit.is_a?(Integer)
+    raise ArgumentError, "limit must be greater than 0" if limit && limit < 1
+    raise ArgumentError, "with_checker must be true or false" unless [true, false].include?(with_checker)
+    raise ArgumentError, "ranges must be true or false" unless [true, false].include?(ranges)
+    raise ArgumentError, "dictionary must be a String path or nil" unless dictionary.nil? || dictionary.is_a?(String)
 
     dict_path = nil
-    if with_checker
-      dict_path = dictionary || Dictionary.path
-    end
+    dict_path = dictionary || Dictionary.path if with_checker
 
     if ranges
       _split_sentences_with_ranges(text, limit, dict_path).map do |(start, finish, sentence)|
@@ -244,12 +210,8 @@ module Kabosu
   #   Kabosu.tokenize("東京都に住んでいる", tokenizer: tok)
   #
   def self.tokenize(text, tokenizer:)
-    unless text.is_a?(String)
-      raise ArgumentError, "text must be a String"
-    end
-    unless tokenizer.is_a?(Tokenizer)
-      raise ArgumentError, "tokenizer must be a Kabosu::Tokenizer"
-    end
+    raise ArgumentError, "text must be a String" unless text.is_a?(String)
+    raise ArgumentError, "tokenizer must be a Kabosu::Tokenizer" unless tokenizer.is_a?(Tokenizer)
 
     batch = tokenizer.__send__(:_tokenize, text)
     cost = batch.respond_to?(:internal_cost) ? batch.internal_cost : nil

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kabosu
 version: !ruby/object:Gem::Version
-  version: 0.6.10.2
+  version: 0.6.11.2
 platform: aarch64-linux
 authors:
 - davafons
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-05-31 00:00:00.000000000 Z
+date: 2026-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -25,61 +25,75 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.3'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: benchmark
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '5.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '13.0'
+        version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: rake-compiler
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
-  name: benchmark
+  name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '1.0'
 description: Kabosu provides Ruby bindings for sudachi.rs, a Rust implementation of
   the Sudachi Japanese morphological analyzer.
 email: 
@@ -109,7 +123,8 @@ files:
 homepage: https://github.com/davafons/kabosu
 licenses:
 - Apache-2.0
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths: