style: standardrb clean across lib (URI.parse().open, ranges, struct, access modifiers)

The ml files merged in #805 had never been linted (rake.yml was red,
so StandardRB never gated them). Autofixes + manual conversions; no
behavior change — imf/provisioning URI fetches keep their open-uri
requires.

Author: ronaldtse

lib/interscript/ml/imf.rb

@@ -32,7 +32,7 @@ def encode(text)
       # corpora emit '/'-separated alternates per token; the runtime
       # returns the primary choice only.
       def first_alternates(text)
-        text.split.map { |tok| tok.split('/', 2).first }.join(' ')
+        text.split.map { |tok| tok.split("/", 2).first }.join(" ")
       end
 
       def decode(token_ids)
@@ -112,7 +112,7 @@ def resolve(model_id, index_url: nil)
           if channel.start_with?("file://")
             FileUtils.cp(channel.sub(%r{\Afile://}, ""), tmp)
           else
-            URI.open(channel) { |remote| IO.copy_stream(remote, tmp) }
+            URI.parse(channel).open { |remote| IO.copy_stream(remote, tmp) }
           end
         end
         actual = Digest::SHA256.file(tmp).hexdigest
@@ -140,14 +140,14 @@ def download_parts(entry, tmp)
             if part["url"].start_with?("file://")
               File.open(source, "rb", &open_stream)
             else
-              URI.open(source, "rb", &open_stream)
+              URI.parse(source).open("rb", &open_stream)
             end
             unless digest.hexdigest == part["sha256"]
               raise RegistryError, "part #{index} of #{entry["filename"]} sha256 mismatch: got #{digest.hexdigest}, index says #{part["sha256"]}"
             end
           end
         end
-      rescue StandardError
+      rescue
         File.delete(tmp) if File.file?(tmp)
         raise
       end
@@ -167,10 +167,10 @@ def load_index(source)
       # HTTP sources must ship a sibling .sha256 sidecar; verify the
       # body against it before parsing (GitHub Releases index assets do).
       def fetch_index_with_sidecar(source)
-        body = URI.open(source, "rb") { |remote| remote.read }
+        body = URI.parse(source).open("rb") { |remote| remote.read }
         sidecar =
           begin
-            URI.open("#{source}.sha256") { |remote| remote.read }
+            URI.parse("#{source}.sha256").open { |remote| remote.read }
           rescue OpenURI::HTTPError => e
             raise RegistryError, "index sha256 sidecar missing: #{source}.sha256 (#{e.message})"
           end

lib/interscript/ml/model.rb

@@ -5,30 +5,30 @@ class Model
     def self.from_file(model_file)
       # A models.yaml model id resolves (download -> verify -> cache)
       # through the same contract as the Python/TS runtimes.
-      model_file = IMF.resolve(model_file) unless model_file.to_s.end_with?('.zip') || File.file?(model_file.to_s)
+      model_file = IMF.resolve(model_file) unless model_file.to_s.end_with?(".zip") || File.file?(model_file.to_s)
       model_file = Provisioning.locate(model_file)
 
       Zip::File.open(model_file) do |zip_file|
-        metadata = zip_file.glob('metadata.yaml').first
+        metadata = zip_file.glob("metadata.yaml").first
         metadata = YAML.safe_load(metadata.get_input_stream.read) if metadata
 
         # IMF v1: the Interscript Model Format zip.
-        return Byt5Onnx.new(model_file) if metadata && metadata['format'] == 'imf-v1'
+        return Byt5Onnx.new(model_file) if metadata && metadata["format"] == "imf-v1"
 
-        name = metadata && metadata['name']
+        name = metadata && metadata["name"]
 
         # Modern byte-level seq2seq (ByT5 family): encoder.onnx + decoder.onnx.
-        return Byt5Onnx.new(model_file) if name == 'byt5'
+        return Byt5Onnx.new(model_file) if name == "byt5"
 
         # Legacy single-file ONNX transformer zips (vocabs.yaml based).
-        vocabs = zip_file.glob('vocabs.yaml').first
-        raise 'vocabs.yaml is missing in model zip!' unless vocabs
+        vocabs = zip_file.glob("vocabs.yaml").first
+        raise "vocabs.yaml is missing in model zip!" unless vocabs
         vocabs = YAML.safe_load(vocabs.get_input_stream.read)
-        input_vocab = Vocab.new(vocabs['input'], specials: [])
-        target_vocab = Vocab.new(vocabs['target'], specials: [])
+        input_vocab = Vocab.new(vocabs["input"], specials: [])
+        target_vocab = Vocab.new(vocabs["target"], specials: [])
 
-        onnx = zip_file.glob('*.onnx').first
-        raise 'onnx model file is missing in model zip!' unless onnx
+        onnx = zip_file.glob("*.onnx").first
+        raise "onnx model file is missing in model zip!" unless onnx
         Onnx.new(onnx.get_input_stream.read, input_vocab, target_vocab)
       end
     end
@@ -41,11 +41,11 @@ def initialize(model_path_or_bytes, input_vocab, target_vocab)
       end
 
       def call(input, output, opts)
-        @model.predict({ src: input, tgt: output }.merge(opts))['output']
+        @model.predict({src: input, tgt: output}.merge(opts))["output"]
       end
 
       def argmax(*args)
-        self.call(*args).map { |i| i.flatten.each_with_index.max[1] }
+        call(*args).map { |i| i.flatten.each_with_index.max[1] }
       end
     end
   end

lib/interscript/ml/plane.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'tmpdir'
-require 'json'
+require "tmpdir"
+require "json"
 
 module Interscript
   module ML
@@ -16,7 +16,7 @@ class PlaneModel
       attr_reader :classes, :k_passes
 
       def initialize(graph:, classes:, k_passes: 2)
-        Interscript::ML.require_optional!('onnxruntime')
+        Interscript::ML.require_optional!("onnxruntime")
         @classes = classes.freeze
         @n_classes = classes.length
         @mask_id = @n_classes
@@ -27,8 +27,8 @@ def initialize(graph:, classes:, k_passes: 2)
         @class_to_id = classes.each_with_index.to_h.freeze
         # the onnxruntime gem loads from paths, not bytes (as byt5_onnx):
         # verified bytes go to a tmpfile owned by this instance
-        @graph_tmpdir = Dir.mktmpdir('isx-plane')
-        path = File.join(@graph_tmpdir, 'plane.onnx')
+        @graph_tmpdir = Dir.mktmpdir("isx-plane")
+        path = File.join(@graph_tmpdir, "plane.onnx")
         File.binwrite(path, graph)
         @sess = OnnxRuntime::Model.new(path)
       end
@@ -58,7 +58,7 @@ def split_planes(text)
           else
             close.call
             skeleton << ch
-            classes << ''
+            classes << ""
           end
         end
         close.call
@@ -75,18 +75,18 @@ def translate(text, preserve_diacritics: false)
           ch = skeleton[i]
           n = ch.bytesize
           cls = if user_cls.empty?
-                  votes = tok_preds[pos, n] || []
-                  cid = votes.tally.max_by { |_, c| c }&.first || @n_classes
-                  cid < @n_classes ? @classes[cid] : ''
-                else
-                  user_cls # user diacritics round-trip byte-exactly
-                end
+            votes = tok_preds[pos, n] || []
+            cid = votes.tally.max_by { |_, c| c }&.first || @n_classes
+            (cid < @n_classes) ? @classes[cid] : ""
+          else
+            user_cls # user diacritics round-trip byte-exactly
+          end
           pos += n
           cls
         end
         out = +""
         skeleton.each_char.with_index do |ch, i|
-          out << (ch == "\x00" ? final[i] : ch + final[i])
+          out << ((ch == "\x00") ? final[i] : ch + final[i])
         end
         out
       end
@@ -102,7 +102,7 @@ def translate_plain(text)
           votes = preds[pos, nbytes] || []
           cid = votes.tally.max_by { |_, c| c }&.first || @n_classes
           pos += nbytes
-          cid < @n_classes ? @classes[cid] : ''
+          (cid < @n_classes) ? @classes[cid] : ""
         end
         PlaneModel.render_plane(text, char_preds)
       end
@@ -111,7 +111,7 @@ def k_pass_decode(ids, plane0)
         plane = plane0
         preds = nil
         @k_passes.times do
-          logits = @sess.predict({ 'input_ids' => [ids], 'plane_ids' => [plane] })['class_logits'][0]
+          logits = @sess.predict({"input_ids" => [ids], "plane_ids" => [plane]})["class_logits"][0]
           preds = logits.each_with_index.map { |row, i| row.index(row.max) }
           plane = preds
         end
@@ -129,11 +129,11 @@ def decode_pinned(skeleton, char_classes)
           pid = @class_to_id.fetch(cls, @mask_id)
           ch.bytesize.times { per_token_pin << pid }
         end
-        plane0 = per_token_pin.map { |p| p == @mask_id ? @mask_id : p }
+        plane0 = per_token_pin.map { |p| (p == @mask_id) ? @mask_id : p }
         k_pass_decode(ids, plane0)
       end
 
-      def self.render_plane(skeleton, char_classes)
+      def self.render_plane(skeleton, char_classes)  # rubocop:disable Lint/IneffectiveAccessModifier
         skeleton.each_char.with_index.map do |ch, i|
           ch + char_classes[i].to_s
         end.join
@@ -142,14 +142,15 @@ def self.render_plane(skeleton, char_classes)
       # The zip contract: metadata.yaml (kind=plane, k_passes, member
       # sha256s) + plane.onnx + classes.json, every member sha-verified
       # before the session is created.
+      # rubocop:disable Lint/IneffectiveAccessModifier
       def self.from_zip(data)
-        require 'zip'
+        require "zip"
         zf = Zip::File.open_buffer(data)
         names = zf.entries.map(&:name)
-        meta = YAML.safe_load(zf.read('metadata.yaml'), permitted_classes: [], aliases: false)
-        raise IMF::FormatError, "plane zip: kind=#{meta['kind'].inspect}, expected 'plane'" if meta['kind'] != 'plane'
+        meta = YAML.safe_load(zf.read("metadata.yaml"), permitted_classes: [], aliases: false)
+        raise IMF::FormatError, "plane zip: kind=#{meta["kind"].inspect}, expected 'plane'" if meta["kind"] != "plane"
 
-        members = meta['members'] || {}
+        members = meta["members"] || {}
         plane_graph = nil
         classes_bytes = nil
         %w[plane.onnx classes.json].each do |member|
@@ -161,18 +162,20 @@ def self.from_zip(data)
           got = Digest::SHA256.hexdigest(bytes)
           raise IMF::FormatError, "plane zip: #{member} sha256 mismatch (#{got})" if want != got
 
-          plane_graph = bytes if member == 'plane.onnx'
-          classes_bytes = bytes if member == 'classes.json'
+          plane_graph = bytes if member == "plane.onnx"
+          classes_bytes = bytes if member == "classes.json"
         end
         classes = JSON.parse(classes_bytes)
-        new(graph: plane_graph, classes: classes, k_passes: meta.fetch('k_passes', 2))
+        new(graph: plane_graph, classes: classes, k_passes: meta.fetch("k_passes", 2))
       ensure
         zf&.close
       end
     end
 
     module_function
 
+    # rubocop:enable Lint/IneffectiveAccessModifier
+
     def render_plane(skeleton, char_classes)
       PlaneModel.render_plane(skeleton, char_classes)
     end

lib/interscript/ml/provisioning.rb

@@ -1,8 +1,8 @@
-require 'open-uri'
-require 'uri'
-require 'fileutils'
-require 'digest/sha2'
-require 'yaml'
+require "open-uri"
+require "uri"
+require "fileutils"
+require "digest/sha2"
+require "yaml"
 
 module Interscript::ML
   # Module Interscript::ML::Provisioning is to provision remote models locally and to
@@ -37,7 +37,7 @@ def prepare_environment
 
       ([ENV["INTERSCRIPT_ML_DATA"] || ENV["SECRYST_DATA"]] + possible_paths).compact.each do |path|
         FileUtils.mkdir_p(path)
-        @write_path = path unless @write_path
+        @write_path ||= path
       rescue
       ensure
         @read_paths << path if File.readable?(path)
@@ -48,11 +48,11 @@ def prepare_environment
       # Now, let's locate the first Secrystfile to be found
       path = Dir.pwd
       secrystfilepath = loop do
-        break unless path =~ %r{[/\\]}
+        break unless %r{[/\\]}.match?(path)
         if File.readable?(path + "/Secrystfile")
           break path + "/Secrystfile"
         end
-        path = path.sub(%r{[/\\][^/\\]*?\z}, '')
+        path = path.sub(%r{[/\\][^/\\]*?\z}, "")
       end
 
       # It's found, so let's parse it.
@@ -70,12 +70,12 @@ def prepare_environment
       @loaded_remotes = @remotes.map do |uri|
         cache_path = "#{@write_path}/remotes/#{Digest::SHA256.hexdigest(uri)}.yaml"
         if !File.exist?(cache_path)
-          data = URI.open(uri).read
+          data = URI.parse(uri).open.read
           File.write(cache_path, data)
         elsif File.mtime(cache_path) + 60 < Time.now
           begin
             # Just *try* to download it.
-            data = URI.open(uri).read
+            data = URI.parse(uri).open.read
             File.write(cache_path, data)
           rescue
           end
@@ -99,7 +99,7 @@ def self.candidate_paths
 
     def locate(name)
       # Shortcut this if user gave a filename.
-      return name if name =~ %r{[.\\/]}
+      return name if %r{[.\\/]}.match?(name)
 
       prepare_environment
 
@@ -130,24 +130,24 @@ def locate(name)
 
     def download(model, remote:)
       uri = model.uri
-      if uri.start_with?("./") || uri.start_with?("../")
+      if uri.start_with?("./", "../")
         remote_uri = remote.uri
-        if remote_uri =~ %r{\A/|\A\w:[\\/]}
-          remote_uri = "file://"+remote_uri
+        if %r{\A/|\A\w:[\\/]}.match?(remote_uri)
+          remote_uri = "file://" + remote_uri
         end
 
         uri = URI(remote_uri).merge(uri).to_s
-        uri = uri.sub(%r{\Afile://}, '')
+        uri = uri.sub(%r{\Afile://}, "")
       end
 
       warn "* Downloading a Secryst model #{model.name}:#{model.version} from #{uri}..."
 
-      data = URI.open(uri).read
+      data = URI.parse(uri).open.read
       path = @write_path + "/models/" + model.name
       FileUtils.mkdir_p path
       File.write(path + "/version", model.version)
       File.write(path + "/model.zip", data)
-      return path + "/model.zip"
+      path + "/model.zip"
     end
 
     class Remotefile
@@ -166,15 +166,15 @@ def resolve(name)
         end
       end
 
-      class Model < Struct.new(:name, :uri, :version, keyword_init: true)
+      class Model < Struct.new(:name, :uri, :version)
       end
     end
 
     class Secrystfile
       def initialize(path)
         @path = path
         @models, @remotes = [], []
-        self.instance_eval(File.read(path), path)
+        instance_eval(File.read(path), path)
       end
 
       def model(name)

lib/interscript/ml/translator.rb

@@ -6,17 +6,17 @@ class Translator
     attr_accessor :model
 
     def initialize(model_file:)
-      @device = 'cpu'
+      @device = "cpu"
       @model = Model.from_file(model_file)
     end
 
     def translate(phrase, max_seq_length: 100)
       return @model.translate(phrase, max_seq_length: max_seq_length) if @model.is_a?(Byt5Onnx)
 
       Interscript::ML.require_optional!("numo-narray", feature: "numo/narray")
-      input = ['<sos>'] + phrase.chars + ['<eos>']
+      input = ["<sos>"] + phrase.chars + ["<eos>"]
       input = Numo::NArray[input.map { |i| @model.input_vocab.stoi[i] }].transpose
-      output = Numo::NArray[[@model.target_vocab.stoi['<sos>']]]
+      output = Numo::NArray[[@model.target_vocab.stoi["<sos>"]]]
       src_key_padding_mask = input.transpose.eq(1)
 
       max_seq_length.times do |i|
@@ -27,12 +27,12 @@ def translate(phrase, max_seq_length: 100)
           src_key_padding_mask: src_key_padding_mask,
           tgt_key_padding_mask: tgt_key_padding_mask,
           memory_key_padding_mask: src_key_padding_mask)
-        break if @model.target_vocab.itos[prediction[i]] == '<eos>'
+        break if @model.target_vocab.itos[prediction[i]] == "<eos>"
 
         output = Numo::NArray.concatenate([output, Numo::NArray[[prediction[i]]]])
       end
 
-      output[1..-1].to_a.flatten.map { |i| @model.target_vocab.itos[i] }.join('')
+      output[1..].to_a.flatten.map { |i| @model.target_vocab.itos[i] }.join("")
     end
   end
 end