Attempt to sorbetize #1sorbet

10 files changed, 183 insertions, 83 deletions

diff --git a/lib/diff/lcs/array.rb b/lib/diff/lcs/array.rb
index 88035ae..80a5c6e 100644
--- a/lib/diff/lcs/array.rb
+++ b/lib/diff/lcs/array.rb
@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: strict
 
 require 'diff/lcs'
 
diff --git a/lib/diff/lcs/backports.rb b/lib/diff/lcs/backports.rb
index 642fc9c..7109368 100644
--- a/lib/diff/lcs/backports.rb
+++ b/lib/diff/lcs/backports.rb
@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 unless 0.respond_to?(:positive?)
   class Fixnum # rubocop:disable Lint/UnifiedInteger, Style/Documentation
diff --git a/lib/diff/lcs/block.rb b/lib/diff/lcs/block.rb
index 430702d..d31a4d3 100644
--- a/lib/diff/lcs/block.rb
+++ b/lib/diff/lcs/block.rb
@@ -1,15 +1,31 @@
 # frozen_string_literal: true
+# typed: strict
 
 # A block is an operation removing, adding, or changing a group of items.
 # Basically, this is just a list of changes, where each change adds or
 # deletes a single item. Used by bin/ldiff.
 class Diff::LCS::Block
-  attr_reader :changes, :insert, :remove
+  extend T::Sig
 
+  ArrayOfChange = T.type_alias { T::Array[Diff::LCS::Change] }
+
+  # The full set of changes in the block.
+  sig { returns(ArrayOfChange) }
+  attr_reader :changes
+
+  # The insertions in the block.
+  sig { returns(ArrayOfChange) }
+  attr_reader :insert
+
+  # The deletions in the block.
+  sig { returns(ArrayOfChange) }
+  attr_reader :remove
+
+  sig { params(chunk: ArrayOfChange).void }
   def initialize(chunk)
-    @changes = []
-    @insert = []
-    @remove = []
+    @changes = T.let([], ArrayOfChange)
+    @insert = T.let([], ArrayOfChange)
+    @remove = T.let([], ArrayOfChange)
 
     chunk.each do |item|
       @changes << item
@@ -18,12 +34,14 @@ class Diff::LCS::Block
     end
   end
 
+  sig { returns(Integer) }
   def diff_size
-    @insert.size - @remove.size
+    insert.size - remove.size
   end
 
+  sig { returns(String) }
   def op
-    case [@remove.empty?, @insert.empty?]
+    case [remove.empty?, insert.empty?]
     when [false, false]
       '!'
     when [false, true]
diff --git a/lib/diff/lcs/callbacks.rb b/lib/diff/lcs/callbacks.rb
index a86f296..f3565a8 100644
--- a/lib/diff/lcs/callbacks.rb
+++ b/lib/diff/lcs/callbacks.rb
@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 require 'diff/lcs/change'
 
diff --git a/lib/diff/lcs/change.rb b/lib/diff/lcs/change.rb
index 7977be5..520aeda 100644
--- a/lib/diff/lcs/change.rb
+++ b/lib/diff/lcs/change.rb
@@ -1,107 +1,133 @@
 # frozen_string_literal: true
+# typed: strict
 
 # Represents a simplistic (non-contextual) change. Represents the removal or
 # addition of an element from either the old or the new sequenced
 # enumerable.
 class Diff::LCS::Change
-  INTEGER = 1.class # Fixnum is deprecated in Ruby 2.4
+  extend T::Sig
+
+  ArrayT = T.type_alias{
+    T.any(
+      [String, Integer, T.untyped],
+      [String, Integer, T.untyped, Integer, T.untyped],
+      [String, [Integer, T.untyped], [Integer, T.untyped]]
+    )
+  }
+
+  ChangeT = T.type_alias { T.any(Diff::LCS::Change, Diff::LCS::ContextChange) }
 
   # The only actions valid for changes are '+' (add), '-' (delete), '='
   # (no change), '!' (changed), '<' (tail changes from first sequence), or
   # '>' (tail changes from second sequence). The last two ('<>') are only
   # found with Diff::LCS::diff and Diff::LCS::sdiff.
-  VALID_ACTIONS = %w(+ - = ! > <).freeze
+  VALID_ACTIONS = T.let(%w(+ - = ! > <).freeze, T::Array[String])
 
+  sig { params(action: T.any(String, Diff::LCS::Change)).returns(T::Boolean) }
   def self.valid_action?(action)
-    VALID_ACTIONS.include? action
+    return false unless action.kind_of?(String)
+
+    VALID_ACTIONS.include?(action)
   end
 
   # Returns the action this Change represents.
+  sig { returns(String) }
   attr_reader :action
+
   # Returns the position of the Change.
+  sig { returns(Integer) }
   attr_reader :position
+
   # Returns the sequence element of the Change.
+  sig { returns(T.untyped) }
   attr_reader :element
 
-  def initialize(*args)
-    @action, @position, @element = *args
+  sig {
+    params(
+      action: String,
+      position: Integer,
+      element: T.untyped,
+      _: T.untyped
+    ).void
+  }
+  def initialize(action, position, element, *_)
+    @action = action
+    @position = position
+    @element = element
 
     fail "Invalid Change Action '#{@action}'" unless Diff::LCS::Change.valid_action?(@action)
-    fail 'Invalid Position Type' unless @position.kind_of? INTEGER
+    fail 'Invalid Position Type' unless @position.kind_of? Integer
   end
 
+  sig { params(_args: T.untyped).returns(String) }
   def inspect(*_args)
     "#<#{self.class}: #{to_a.inspect}>"
   end
 
+  sig { returns(ArrayT) }
   def to_a
     [@action, @position, @element]
   end
 
   alias to_ary to_a
 
+  sig { params(arr: ArrayT).returns(ChangeT) }
   def self.from_a(arr)
     arr = arr.flatten(1)
     case arr.size
     when 5
-      Diff::LCS::ContextChange.new(*(arr[0...5]))
+      Diff::LCS::ContextChange.new(arr[0], arr[1], arr[2], arr[3], arr[4])
     when 3
-      Diff::LCS::Change.new(*(arr[0...3]))
+      Diff::LCS::Change.new(arr[0], arr[1], arr[2])
     else
       fail 'Invalid change array format provided.'
     end
   end
 
-  def to_change(action)
-    args =
-      case action
-      when '-'
-        [action, old_position, old_element]
-      when '+'
-        [action, new_position, new_element]
-      else
-        fail 'Invalid action for creating a change'
-      end
-
-    Diff::LCS::Change.new(*args)
-  end
-
   include Comparable
 
+  sig { params(other: ChangeT).returns(T::Boolean) }
   def ==(other)
-    (self.class == other.class) and
-      (action == other.action) and
-      (position == other.position) and
-      (element == other.element)
+    self.class == other.class &&
+      action == other.action &&
+      position == other.position &&
+      element == other.element
   end
 
+  sig { params(other: Diff::LCS::Change).returns(Integer) }
   def <=>(other)
     r = action <=> other.action
-    r = position <=> other.position if r.zero?
-    r = element <=> other.element if r.zero?
+    r = position <=> other.position if T.must(r).zero?
+    r = element <=> other.element if T.must(r).zero?
     r
   end
 
+  sig { returns(T::Boolean) }
   def adding?
     @action == '+'
   end
 
+  sig { returns(T::Boolean) }
   def deleting?
     @action == '-'
   end
 
+  sig { returns(T::Boolean) }
   def unchanged?
     @action == '='
   end
 
+  sig { returns(T::Boolean) }
   def changed?
     @action == '!'
   end
 
+  sig { returns(T::Boolean) }
   def finished_a?
     @action == '>'
   end
 
+  sig { returns(T::Boolean) }
   def finished_b?
     @action == '<'
   end
@@ -111,27 +137,51 @@ end
 # elements in the old and the new sequenced enumerables as well as the action
 # taken.
 class Diff::LCS::ContextChange < Diff::LCS::Change
+  extend T::Sig
+
   # We don't need these two values.
   undef :position
   undef :element
 
   # Returns the old position being changed.
+  sig { returns(Integer) }
   attr_reader :old_position
+
   # Returns the new position being changed.
+  sig { returns(Integer) }
   attr_reader :new_position
+
   # Returns the old element being changed.
+  sig { returns(T.untyped) }
   attr_reader :old_element
+
   # Returns the new element being changed.
+  sig { returns(T.untyped) }
   attr_reader :new_element
 
-  def initialize(*args)
-    @action, @old_position, @old_element, @new_position, @new_element = *args
+  sig {
+    params(
+      action: String,
+      old_position: Integer,
+      old_element: T.untyped,
+      new_position: Integer,
+      new_element: T.untyped,
+      _: T.untyped
+    ).void
+  }
+  def initialize(action, old_position, old_element, new_position, new_element, *_)
+    @action = action
+    @old_position = old_position
+    @old_element = old_element
+    @new_position = new_position
+    @new_element = new_element
 
     fail "Invalid Change Action '#{@action}'" unless Diff::LCS::Change.valid_action?(@action)
-    fail 'Invalid (Old) Position Type' unless @old_position.nil? or @old_position.kind_of? INTEGER
-    fail 'Invalid (New) Position Type' unless @new_position.nil? or @new_position.kind_of? INTEGER
+    fail 'Invalid (Old) Position Type' unless @old_position.nil? or @old_position.kind_of? Integer
+    fail 'Invalid (New) Position Type' unless @new_position.nil? or @new_position.kind_of? Integer
   end
 
+  sig { returns(ArrayT) }
   def to_a
     [
       @action,
@@ -142,12 +192,26 @@ class Diff::LCS::ContextChange < Diff::LCS::Change
 
   alias to_ary to_a
 
+  sig { params(action: String).returns(Diff::LCS::Change) }
+  def to_change(action)
+    case action
+    when '-'
+      Diff::LCS::Change.new(action, old_position, old_element)
+    when '+'
+      Diff::LCS::Change.new(action, new_position, new_element)
+    else
+      fail 'Invalid action for creating a change'
+    end
+  end
+
+  sig { params(arr: ArrayT).returns(ChangeT) }
   def self.from_a(arr)
     Diff::LCS::Change.from_a(arr)
   end
 
   # Simplifies a context change for use in some diff callbacks. '<' actions
   # are converted to '-' and '>' actions are converted to '+'.
+  sig { returns(T.any(Diff::LCS::Change, Diff::LCS::ContextChange)) }
   def simplify
     args =
       case action
@@ -164,24 +228,33 @@ class Diff::LCS::ContextChange < Diff::LCS::Change
 
   # Simplifies a context change for use in some diff callbacks. '<' actions
   # are converted to '-' and '>' actions are converted to '+'.
+  sig {
+    params(event: Diff::LCS::ContextChange).returns(T.any(
+      Diff::LCS::Change,
+      Diff::LCS::ContextChange
+    ))
+  }
   def self.simplify(event)
     event.simplify
   end
 
+  sig { params(other: ChangeT).returns(T::Boolean) }
   def ==(other)
-    (self.class == other.class) and
-      (@action == other.action) and
-      (@old_position == other.old_position) and
-      (@new_position == other.new_position) and
-      (@old_element == other.old_element) and
-      (@new_element == other.new_element)
+    return false unless other.kind_of?(Diff::LCS::ContextChange)
+
+    @action == other.action &&
+      @old_position == other.old_position &&
+      @new_position == other.new_position &&
+      @old_element == other.old_element &&
+      @new_element == other.new_element
   end
 
+  sig { params(other: Diff::LCS::ContextChange).returns(Integer) }
   def <=>(other)
     r = @action <=> other.action
-    r = @old_position <=> other.old_position if r.zero?
-    r = @new_position <=> other.new_position if r.zero?
-    r = @old_element <=> other.old_element if r.zero?
+    r = @old_position <=> other.old_position if T.must(r).zero?
+    r = @new_position <=> other.new_position if T.must(r).zero?
+    r = @old_element <=> other.old_element if T.must(r).zero?
     r = @new_element <=> other.new_element if r.zero?
     r
   end
diff --git a/lib/diff/lcs/htmldiff.rb b/lib/diff/lcs/htmldiff.rb
index f12220b..54ce9f4 100644
--- a/lib/diff/lcs/htmldiff.rb
+++ b/lib/diff/lcs/htmldiff.rb
@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: false
 
 require 'cgi'
 
@@ -112,8 +113,8 @@ h1 { margin-left: 2em; }
   def run
     verify_options
 
-    if @options[:expand_tabs].positive? && self.class.can_expand_tabs
-      formatter = Text::Format.new
+    if @options[:expand_tabs].positive? && self.class.can_expand_tabs && defined? ::Text::Format
+      formatter = ::Text::Format.new
       formatter.tabstop = @options[:expand_tabs]
 
       @left.map! do |line| formatter.expand(line.chomp) end
diff --git a/lib/diff/lcs/hunk.rb b/lib/diff/lcs/hunk.rb
index fc5a035..ba16e11 100644
--- a/lib/diff/lcs/hunk.rb
+++ b/lib/diff/lcs/hunk.rb
@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 require 'diff/lcs/block'
 
@@ -15,9 +16,10 @@ class Diff::LCS::Hunk
   # piece of data.
   def initialize(data_old, data_new, piece, flag_context, file_length_difference)
     # At first, a hunk will have just one Block in it
-    @blocks = [Diff::LCS::Block.new(piece)]
+    block = Diff::LCS::Block.new(piece)
+    @blocks = T.let([block], T::Array[Diff::LCS::Block])
 
-    if @blocks[0].remove.empty? && @blocks[0].insert.empty?
+    if block.remove.empty? && block.insert.empty?
       fail "Cannot build a hunk from #{piece.inspect}; has no add or remove actions"
     end
 
@@ -29,7 +31,7 @@ class Diff::LCS::Hunk
     @data_new = data_new
 
     before = after = file_length_difference
-    after += @blocks[0].diff_size
+    after += block.diff_size
     @file_length_difference = after # The caller must get this manually
     @max_diff_size = @blocks.map { |e| e.diff_size.abs }.max
 
@@ -37,24 +39,24 @@ class Diff::LCS::Hunk
     # we're only adding items in this block), then figure out the line number
     # based on the line number of the other file and the current difference in
     # file lengths.
-    if @blocks[0].remove.empty?
+    if block.remove.empty?
       a1 = a2 = nil
     else
-      a1 = @blocks[0].remove[0].position
-      a2 = @blocks[0].remove[-1].position
+      a1 = T.must(block.remove[0]).position
+      a2 = T.must(block.remove[-1]).position
     end
 
-    if @blocks[0].insert.empty?
+    if block.insert.empty?
       b1 = b2 = nil
     else
-      b1 = @blocks[0].insert[0].position
-      b2 = @blocks[0].insert[-1].position
+      b1 = T.must(block.insert[0]).position
+      b2 = T.must(block.insert[-1]).position
     end
 
-    @start_old = a1 || (b1 - before)
-    @start_new = b1 || (a1 + before)
-    @end_old   = a2 || (b2 - after)
-    @end_new   = b2 || (a2 + after)
+    @start_old = a1 || (T.must(b1) - before)
+    @start_new = b1 || (T.must(a1) + before)
+    @end_old   = a2 || (T.must(b2) - after)
+    @end_new   = b2 || (T.must(a2) + after)
 
     self.flag_context = flag_context
   end
@@ -134,7 +136,7 @@ class Diff::LCS::Hunk
   def old_diff(_last = false)
     warn 'Expecting only one block in an old diff hunk!' if @blocks.size > 1
 
-    block = @blocks[0]
+    block = T.must(@blocks[0])
 
     # Calculate item number range. Old diff range is just like a context
     # diff range, except the ranges are on one line with the action between
@@ -142,13 +144,13 @@ class Diff::LCS::Hunk
     s = encode("#{context_range(:old, ',')}#{OLD_DIFF_OP_ACTION[block.op]}#{context_range(:new, ',')}\n")
     # If removing anything, just print out all the remove lines in the hunk
     # which is just all the remove lines in the block.
-    unless block.remove.empty?
+    unless T.must(block).remove.empty?
       @data_old[@start_old..@end_old].each { |e| s << encode('< ') + e.chomp + encode("\n") }
     end
 
     s << encode("---\n") if block.op == '!'
 
-    unless block.insert.empty?
+    unless T.must(block).insert.empty?
       @data_new[@start_new..@end_new].each { |e| s << encode('> ') + e.chomp + encode("\n") }
     end
 
@@ -270,14 +272,16 @@ class Diff::LCS::Hunk
   def ed_diff(format, _last = false)
     warn 'Expecting only one block in an old diff hunk!' if @blocks.size > 1
 
+    block = T.must(@blocks[0])
+
     s =
       if format == :reverse_ed
-        encode("#{ED_DIFF_OP_ACTION[@blocks[0].op]}#{context_range(:old, ',')}\n")
+        encode("#{ED_DIFF_OP_ACTION[block.op]}#{context_range(:old, ',')}\n")
       else
-        encode("#{context_range(:old, ' ')}#{ED_DIFF_OP_ACTION[@blocks[0].op]}\n")
+        encode("#{context_range(:old, ' ')}#{ED_DIFF_OP_ACTION[block.op]}\n")
       end
 
-    unless @blocks[0].insert.empty?
+    unless block.insert.empty?
       @data_new[@start_new..@end_new].each do |e|
         s << e.chomp + encode("\n")
       end
diff --git a/lib/diff/lcs/internals.rb b/lib/diff/lcs/internals.rb
index 60027f2..f73ba52 100644
--- a/lib/diff/lcs/internals.rb
+++ b/lib/diff/lcs/internals.rb
@@ -1,7 +1,8 @@
 # frozen_string_literal: true
+# typed: true
 
-class << Diff::LCS
-  def diff_traversal(method, seq1, seq2, callbacks, &block)
+module Diff::LCS # rubocop:disable Style/Documentation
+  def self.diff_traversal(method, seq1, seq2, callbacks, &block)
     callbacks = callbacks_for(callbacks)
     case method
     when :diff
@@ -26,10 +27,7 @@ class << Diff::LCS
   private :diff_traversal
 end
 
-module Diff::LCS::Internals # :nodoc:
-end
-
-class << Diff::LCS::Internals
+module Diff::LCS::Internals # :nodoc: rubocop:disable Style/Documentation
   # Compute the longest common subsequence between the sequenced
   # Enumerables +a+ and +b+. The result is an array whose contents is such
   # that
@@ -38,7 +36,7 @@ class << Diff::LCS::Internals
   #     result.each_with_index do |e, i|
   #       assert_equal(a[i], b[e]) unless e.nil?
   #     end
-  def lcs(a, b)
+  def self.lcs(a, b)
     a_start = b_start = 0
     a_finish = a.size - 1
     b_finish = b.size - 1
@@ -69,7 +67,8 @@ class << Diff::LCS::Internals
     (a_start..a_finish).each do |i|
       ai = string ? a[i, 1] : a[i]
       bm = b_matches[ai]
-      k = nil
+      k = T.let(nil, T.nilable(Integer))
+
       bm.reverse_each do |j|
         if k and (thresh[k] > j) and (thresh[k - 1] < j)
           thresh[k] = j
@@ -95,10 +94,10 @@ class << Diff::LCS::Internals
   # normalization (conversion of the array form of Diff::LCS::Change objects to
   # the object form of same) and detection of whether the patchset represents
   # changes to be made.
-  def analyze_patchset(patchset, depth = 0)
+  def self.analyze_patchset(patchset, depth = 0)
     fail 'Patchset too complex' if depth > 1
 
-    has_changes = false
+    has_changes = T.let(false, T::Boolean)
     new_patchset = []
 
     # Format:
@@ -116,7 +115,7 @@ class << Diff::LCS::Internals
         new_patchset << hunk
       when Array
         # Detect if the 'hunk' is actually an array-format change object.
-        if Diff::LCS::Change.valid_action? hunk[0]
+        if Diff::LCS::Change.valid_action?(hunk[0])
           hunk = Diff::LCS::Change.from_a(hunk)
           has_changes ||= !hunk.unchanged?
           new_patchset << hunk
@@ -140,7 +139,7 @@ class << Diff::LCS::Internals
   # some time. This also works better with Diff::LCS::ContextChange or
   # Diff::LCS::Change as its source, as an array will cause the creation
   # of one of the above.
-  def intuit_diff_direction(src, patchset, limit = nil)
+  def self.intuit_diff_direction(src, patchset, limit = nil)
     string = src.kind_of?(String)
     count = left_match = left_miss = right_match = right_miss = 0
 
@@ -245,7 +244,7 @@ enumerable as either source or destination value."
   # are numeric.
   #
   # This operation preserves the sort order.
-  def replace_next_larger(enum, value, last_index = nil)
+  def self.replace_next_larger(enum, value, last_index = nil)
     # Off the end?
     if enum.empty? or (value > enum[-1])
       enum << value
@@ -279,7 +278,7 @@ enumerable as either source or destination value."
   # If +vector+ maps the matching elements of another collection onto this
   # Enumerable, compute the inverse of +vector+ that maps this Enumerable
   # onto the collection. (Currently unused.)
-  def inverse_vector(a, vector)
+  def self.inverse_vector(a, vector)
     inverse = a.dup
     (0...vector.size).each do |i|
       inverse[vector[i]] = i unless vector[i].nil?
@@ -291,7 +290,7 @@ enumerable as either source or destination value."
   # Returns a hash mapping each element of an Enumerable to the set of
   # positions it occupies in the Enumerable, optionally restricted to the
   # elements specified in the range of indexes specified by +interval+.
-  def position_hash(enum, interval)
+  def self.position_hash(enum, interval)
     string = enum.kind_of?(String)
     hash = Hash.new { |h, k| h[k] = [] }
     interval.each do |i|
diff --git a/lib/diff/lcs/ldiff.rb b/lib/diff/lcs/ldiff.rb
index 17b374c..d81e392 100644
--- a/lib/diff/lcs/ldiff.rb
+++ b/lib/diff/lcs/ldiff.rb
@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: false
 
 require 'optparse'
 require 'ostruct'
diff --git a/lib/diff/lcs/string.rb b/lib/diff/lcs/string.rb
index 6bcdc74..1ee7a3c 100644
--- a/lib/diff/lcs/string.rb
+++ b/lib/diff/lcs/string.rb
@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: strict
 
 warn 'diff/lcs/string: Automatically extending String with Diff::LCS is deprecated'