diff_match_patch_es 2.0.0

data/lib/diff_match_patch_es/js_string.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module DiffMatchPatchES
+  # Helpers that reproduce JavaScript string semantics exactly.
+  module JsString
+    module_function
+
+    # JS String.prototype.substring: negative/overflowing indices clamp to [0, length] and the arguments swap when start > end.
+    def substring(str, start_index, end_index = nil)
+      len = str.length
+      a = start_index.clamp(0, len)
+      b = end_index.nil? ? len : end_index.clamp(0, len)
+      a, b = b, a if a > b
+      str[a...b]
+    end
+
+    # JS String.prototype.charAt: '' when out of range.
+    def char_at(str, index)
+      return '' if index.negative? || index >= str.length
+
+      str[index]
+    end
+
+    # JS String.prototype.indexOf.
+    def index_of(str, pattern, from = 0)
+      from = from.clamp(0, str.length)
+      str.index(pattern, from) || -1
+    end
+
+    # JS String.prototype.lastIndexOf: the match may start at or before +from+.
+    def last_index_of(str, pattern, from)
+      from = from.clamp(0, str.length)
+      str.rindex(pattern, from) || -1
+    end
+
+    # JS Number.parseInt(str, 10): optional leading whitespace and sign,
+    # JS StrWhiteSpace: ASCII whitespace, NBSP, BOM, and Unicode space separators.
+    JS_PARSE_INT = /\A[\t\n\v\f\r \u00A0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]*([+-]?\d+)/
+
+    # then as many digits as possible. Returns nil where JS returns NaN.
+    def parse_int(str)
+      match = JS_PARSE_INT.match(str)
+      match && match[1].to_i
+    end
+
+    # Characters encodeURI leaves unescaped.
+    ENCODE_URI_UNESCAPED = /\A[A-Za-z0-9;,\/?:@&=+$\-_.!~*'()#]\z/
+    # Characters whose escape sequences decodeURI refuses to decode
+    # (uriReserved plus '#').
+    DECODE_URI_RESERVED = ";/?:@&=+$,#"
+
+    # JS encodeURI: percent-encodes the UTF-8 bytes of every character outside
+    # the unescaped set, using uppercase hex.
+    def encode_uri(str)
+      out = +''
+      str.each_char do |ch|
+        if ENCODE_URI_UNESCAPED.match?(ch)
+          out << ch
+        else
+          ch.each_byte { |b| out << format('%%%02X', b) }
+        end
+      end
+      out
+    end
+
+    class UriError < StandardError; end
+
+    # JS decodeURI: decodes %XX escape sequences as strict UTF-8 (rejecting
+    # malformed, overlong, surrogate, and out-of-range sequences) while leaving
+    # escapes of reserved characters (";/?:@&=+$,#") untouched.
+    def decode_uri(str)
+      out = +''
+      i = 0
+      n = str.length
+      while i < n
+        ch = str[i]
+        unless ch == '%'
+          out << ch
+          i += 1
+          next
+        end
+        start = i
+        b0 = read_escaped_byte(str, i)
+        i += 3
+        if b0 < 0x80
+          decoded = b0.chr
+          if DECODE_URI_RESERVED.include?(decoded)
+            out << str[start, 3]
+          else
+            out << decoded
+          end
+        else
+          extra =
+            case b0
+            when 0xC2..0xDF then 1
+            when 0xE0..0xEF then 2
+            when 0xF0..0xF4 then 3
+            else raise UriError, 'URI malformed'
+            end
+          codepoint = b0 & (0x3F >> extra)
+          extra.times do
+            raise UriError, 'URI malformed' unless str[i] == '%'
+
+            byte = read_escaped_byte(str, i)
+            raise UriError, 'URI malformed' unless (byte & 0xC0) == 0x80
+
+            codepoint = (codepoint << 6) | (byte & 0x3F)
+            i += 3
+          end
+          minimum = [0x80, 0x800, 0x10000][extra - 1]
+          if codepoint < minimum || codepoint > 0x10FFFF || (0xD800..0xDFFF).cover?(codepoint)
+            raise UriError, 'URI malformed'
+          end
+
+          out << codepoint.chr(Encoding::UTF_8)
+        end
+      end
+      out
+    end
+
+    def read_escaped_byte(str, index)
+      hex = str[index + 1, 2]
+      raise UriError, 'URI malformed' unless hex&.length == 2 && /\A\h\h\z/.match?(hex)
+
+      hex.to_i(16)
+    end
+  end
+end

data/lib/diff_match_patch_es/match.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module DiffMatchPatchES
+  # JS bitwise operators coerce to 32-bit integers; Ruby integers are
+  # arbitrary precision, so shifts are masked to keep the two congruent.
+  MASK32 = 0xFFFFFFFF
+  private_constant :MASK32
+
+  module_function
+
+  # Locate the best instance of 'pattern' in 'text' near 'loc'.
+  # Returns the best match index or -1.
+  def match_main(text, pattern, loc, options = nil)
+    # Check for null inputs.
+    raise Error, 'Null input. (match_main)' if text.nil? || pattern.nil? || loc.nil?
+
+    loc = loc.clamp(0, text.length)
+    if text == pattern
+      # Shortcut (potentially not guaranteed by the algorithm)
+      0
+    elsif text.empty?
+      # Nothing to match.
+      -1
+    elsif JsString.substring(text, loc, loc + pattern.length) == pattern
+      # Perfect match at the perfect spot!  (Includes case of null pattern)
+      loc
+    else
+      # Do a fuzzy compare.
+      match_bitap(text, pattern, loc, options)
+    end
+  end
+
+  # Locate the best instance of 'pattern' in 'text' near 'loc' using the
+  # Bitap algorithm.
+  def match_bitap(text, pattern, loc, options = nil)
+    resolved = resolve_options(options)
+
+    raise Error, 'Pattern too long for this browser.' if pattern.length > resolved.match_max_bits
+
+    # Initialise the alphabet.
+    s = match_alphabet(pattern)
+
+    # Compute and return the score for a match with e errors and x location.
+    # (0.0 = good, 1.0 = bad)
+    bitap_score = lambda do |e, x|
+      accuracy = e.fdiv(pattern.length)
+      proximity = (loc - x).abs
+      if resolved.match_distance.zero?
+        # Dodge divide by zero error.
+        return proximity.zero? ? accuracy : 1.0
+      end
+      accuracy + proximity.fdiv(resolved.match_distance)
+    end
+
+    # Highest score beyond which we give up.
+    score_threshold = resolved.match_threshold
+    # Is there a nearby exact match? (speedup)
+    best_loc = JsString.index_of(text, pattern, loc)
+    if best_loc != -1
+      score_threshold = [bitap_score.call(0, best_loc), score_threshold].min
+      # What about in the other direction? (speedup)
+      best_loc = JsString.last_index_of(text, pattern, loc + pattern.length)
+      score_threshold = [bitap_score.call(0, best_loc), score_threshold].min if best_loc != -1
+    end
+
+    # Initialise the bit arrays.
+    matchmask = (1 << (pattern.length - 1)) & MASK32
+    best_loc = -1
+
+    bin_max = pattern.length + text.length
+    last_rd = []
+    d = 0
+    while d < pattern.length
+      # Scan for the best match; each iteration allows for one more error.
+      # Run a binary search to determine how far from 'loc' we can stray at
+      # this error level.
+      bin_min = 0
+      bin_mid = bin_max
+      while bin_min < bin_mid
+        if bitap_score.call(d, loc + bin_mid) <= score_threshold
+          bin_min = bin_mid
+        else
+          bin_max = bin_mid
+        end
+        bin_mid = (bin_max - bin_min) / 2 + bin_min
+      end
+      # Use the result from this iteration as the maximum for the next.
+      bin_max = bin_mid
+      start = [1, loc - bin_mid + 1].max
+      finish = [loc + bin_mid, text.length].min + pattern.length
+
+      rd = Array.new(finish + 2, 0)
+      rd[finish + 1] = ((1 << d) - 1) & MASK32
+      j = finish
+      while j >= start
+        char_match = s[JsString.char_at(text, j - 1)] || 0
+        rd[j] = if d.zero? # First pass: exact match.
+                  (((rd[j + 1] << 1) | 1) & char_match) & MASK32
+                else # Subsequent passes: fuzzy match.
+                  ((((rd[j + 1] << 1) | 1) & char_match) |
+                    ((((last_rd[j + 1] || 0) | (last_rd[j] || 0)) << 1) | 1) |
+                    (last_rd[j + 1] || 0)) & MASK32
+                end
+        if (rd[j] & matchmask) != 0
+          score = bitap_score.call(d, j - 1)
+          # This match will almost certainly be better than any existing
+          # match.  But check anyway.
+          if score <= score_threshold
+            # Told you so.
+            score_threshold = score
+            best_loc = j - 1
+            if best_loc > loc
+              # When passing loc, don't exceed our current distance from loc.
+              start = [1, (2 * loc) - best_loc].max
+            else
+              # Already passed loc, downhill from here on in.
+              break
+            end
+          end
+        end
+        j -= 1
+      end
+      # No hope for a (better) match at greater error levels.
+      break if bitap_score.call(d + 1, loc) > score_threshold
+
+      last_rd = rd
+      d += 1
+    end
+    best_loc
+  end
+
+  # Initialise the alphabet for the Bitap algorithm.
+  def match_alphabet(pattern)
+    s = {}
+    pattern.each_char { |ch| s[ch] = 0 }
+    pattern.length.times do |i|
+      s[pattern[i]] |= (1 << (pattern.length - i - 1)) & MASK32
+    end
+    s
+  end
+end

data/lib/diff_match_patch_es/options.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module DiffMatchPatchES
+  class Options
+    ATTRIBUTES = %i[
+      diff_timeout
+      diff_edit_cost
+      match_threshold
+      match_distance
+      patch_delete_threshold
+      patch_margin
+      match_max_bits
+    ].freeze
+
+    attr_accessor(*ATTRIBUTES)
+
+    def initialize(
+      diff_timeout: 1.0,
+      diff_edit_cost: 4,
+      match_threshold: 0.5,
+      match_distance: 1000,
+      patch_delete_threshold: 0.5,
+      patch_margin: 4,
+      match_max_bits: 32
+    )
+      @diff_timeout = diff_timeout
+      @diff_edit_cost = diff_edit_cost
+      @match_threshold = match_threshold
+      @match_distance = match_distance
+      @patch_delete_threshold = patch_delete_threshold
+      @patch_margin = patch_margin
+      @match_max_bits = match_max_bits
+    end
+
+    def to_h
+      ATTRIBUTES.to_h { |name| [name, public_send(name)] }
+    end
+
+    def ==(other)
+      other.is_a?(Options) && to_h == other.to_h
+    end
+  end
+
+  DEFAULT_OPTIONS = Options.new.freeze
+
+  module_function
+
+  # Accepts nil, a Hash of overrides, or an already-resolved Options.
+  def resolve_options(options = nil)
+    case options
+    when Options then options
+    when nil then Options.new
+    when Hash then Options.new(**options)
+    else
+      raise ArgumentError, "Unsupported options: #{options.inspect}"
+    end
+  end
+end