diff-lcs 1.3 → 1.4.4

data/lib/diff/lcs/array.rb

@@ -1,4 +1,4 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'diff/lcs'
 

data/lib/diff/lcs/backports.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+unless 0.respond_to?(:positive?)
+  class Fixnum # rubocop:disable Lint/UnifiedInteger, Style/Documentation
+    def positive?
+      self > 0 # rubocop:disable Style/NumericPredicate
+    end
+  end
+end

data/lib/diff/lcs/block.rb

@@ -1,4 +1,4 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 # 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

data/lib/diff/lcs/callbacks.rb

@@ -1,8 +1,8 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'diff/lcs/change'
 
-module Diff::LCS
+module Diff::LCS # rubocop:disable Style/Documentation
   # This callback object implements the default set of callback events,
   # which only returns the event itself. Note that #finished_a and
   # #finished_b are not implemented -- I haven't yet figured out where they
@@ -17,14 +17,17 @@ module Diff::LCS
       def match(event)
         event
       end
+
       # Called when the old value is discarded in favour of the new value.
       def discard_a(event)
         event
       end
+
       # Called when the new value is discarded in favour of the old value.
       def discard_b(event)
         event
       end
+
       # Called when both the old and new values have changed.
       def change(event)
         event
@@ -108,12 +111,12 @@ class Diff::LCS::DiffCallbacks
     @hunk = []
     @diffs = []
 
-    if block_given?
-      begin
-        yield self
-      ensure
-        self.finish
-      end
+    return unless block_given?
+
+    begin
+      yield self
+    ensure
+      finish
     end
   end
 
@@ -123,7 +126,7 @@ class Diff::LCS::DiffCallbacks
     finish_hunk
   end
 
-  def match(event)
+  def match(_event)
     finish_hunk
   end
 
@@ -190,7 +193,7 @@ end
 # Diff::LCS::SDiffCallbacks. They may be compared as:
 #
 #     s = Diff::LCS.sdiff(seq1, seq2).reject { |e| e.action == "=" }
-#     c = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextDiffCallbacks).flatten
+#     c = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextDiffCallbacks).flatten(1)
 #
 #     s == c # -> true
 #
@@ -241,7 +244,7 @@ end
 # will compute and display the necessary components to show two sequences
 # and their minimized differences side by side, just like the Unix utility
 # +sdiff+.
-# 
+#
 #     same             same
 #     before     |     after
 #     old        <     -
@@ -270,7 +273,7 @@ end
 # Diff::LCS::ContextDiffCallbacks. They may be compared as:
 #
 #     s = Diff::LCS.sdiff(seq1, seq2).reject { |e| e.action == "=" }
-#     c = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextDiffCallbacks).flatten
+#     c = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextDiffCallbacks).flatten(1)
 #
 #     s == c # -> true
 #

data/lib/diff/lcs/change.rb

@@ -1,16 +1,16 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 # 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
-  IntClass = 1.class # Fixnum is deprecated in Ruby 2.4
+  IntClass = 1.class # Fixnum is deprecated in Ruby 2.4 # rubocop:disable Naming/ConstantName
 
   # 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(+ - = ! > <)
+  VALID_ACTIONS = %w(+ - = ! > <).freeze
 
   def self.valid_action?(action)
     VALID_ACTIONS.include? action
@@ -27,20 +27,20 @@ class Diff::LCS::Change
   def initialize(*args)
     @action, @position, @element = *args
 
-    unless Diff::LCS::Change.valid_action?(@action)
-      raise "Invalid Change Action '#{@action}'"
-    end
-    raise "Invalid Position Type" unless @position.kind_of? IntClass
+    fail "Invalid Change Action '#{@action}'" unless Diff::LCS::Change.valid_action?(@action)
+    fail 'Invalid Position Type' unless @position.kind_of? IntClass
   end
 
-  def inspect
-    to_a.inspect
+  def inspect(*_args)
+    "#<#{self.class}: #{to_a.inspect}>"
   end
 
   def to_a
-    [ @action, @position, @element ]
+    [@action, @position, @element]
   end
 
+  alias to_ary to_a
+
   def self.from_a(arr)
     arr = arr.flatten(1)
     case arr.size
@@ -49,7 +49,7 @@ class Diff::LCS::Change
     when 3
       Diff::LCS::Change.new(*(arr[0...3]))
     else
-      raise "Invalid change array format provided."
+      fail 'Invalid change array format provided.'
     end
   end
 
@@ -57,15 +57,15 @@ class Diff::LCS::Change
 
   def ==(other)
     (self.class == other.class) and
-    (self.action == other.action) and
-    (self.position == other.position) and
-    (self.element == other.element)
+      (action == other.action) and
+      (position == other.position) and
+      (element == other.element)
   end
 
   def <=>(other)
-    r = self.action <=> other.action
-    r = self.position <=> other.position if r.zero?
-    r = self.element <=> other.element if r.zero?
+    r = action <=> other.action
+    r = position <=> other.position if r.zero?
+    r = element <=> other.element if r.zero?
     r
   end
 
@@ -114,27 +114,20 @@ class Diff::LCS::ContextChange < Diff::LCS::Change
   def initialize(*args)
     @action, @old_position, @old_element, @new_position, @new_element = *args
 
-    unless Diff::LCS::Change.valid_action?(@action)
-      raise "Invalid Change Action '#{@action}'"
-    end
-    unless @old_position.nil? or @old_position.kind_of? IntClass
-      raise "Invalid (Old) Position Type"
-    end
-    unless @new_position.nil? or @new_position.kind_of? IntClass
-      raise "Invalid (New) Position Type"
-    end
+    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? IntClass
+    fail 'Invalid (New) Position Type' unless @new_position.nil? or @new_position.kind_of? IntClass
   end
 
   def to_a
-    [ @action,
-      [ @old_position, @old_element ],
-      [ @new_position, @new_element ]
+    [
+      @action,
+      [@old_position, @old_element],
+      [@new_position, @new_element]
     ]
   end
 
-  def inspect(*args)
-    to_a.inspect
-  end
+  alias to_ary to_a
 
   def self.from_a(arr)
     Diff::LCS::Change.from_a(arr)
@@ -163,11 +156,11 @@ class Diff::LCS::ContextChange < Diff::LCS::Change
 
   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)
+      (@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)
   end
 
   def <=>(other)

data/lib/diff/lcs/htmldiff.rb

@@ -1,14 +1,15 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'cgi'
 
+# Produce a simple HTML diff view.
 class Diff::LCS::HTMLDiff
   class << self
     attr_accessor :can_expand_tabs #:nodoc:
   end
   self.can_expand_tabs = true
 
-  class Callbacks
+  class Callbacks #:nodoc:
     attr_accessor :output
     attr_accessor :match_class
     attr_accessor :only_a_class
@@ -18,14 +19,14 @@ class Diff::LCS::HTMLDiff
       @output = output
       options ||= {}
 
-      @match_class = options[:match_class] || "match"
-      @only_a_class = options[:only_a_class] || "only_a"
-      @only_b_class = options[:only_b_class] || "only_b"
+      @match_class = options[:match_class] || 'match'
+      @only_a_class = options[:only_a_class] || 'only_a'
+      @only_b_class = options[:only_b_class] || 'only_b'
     end
 
     def htmlize(element, css_class)
-      element = "&nbsp;" if element.empty?
-      %Q|<pre class="#{__send__(css_class)}">#{element}</pre>\n|
+      element = '&nbsp;' if element.empty?
+      %Q(<pre class="#{__send__(css_class)}">#{element}</pre>\n)
     end
     private :htmlize
 
@@ -49,8 +50,8 @@ class Diff::LCS::HTMLDiff
     :expand_tabs => nil,
     :output => nil,
     :css => nil,
-    :title => nil,
-  }
+    :title => nil
+  }.freeze
 
   DEFAULT_CSS = <<-CSS
 body { margin: 0; }
@@ -96,13 +97,13 @@ h1 { margin-left: 2em; }
 
   def verify_options
     @options[:expand_tabs] ||= 4
-    @options[:expand_tabs] = 4 if @options[:expand_tabs] < 0
+    @options[:expand_tabs] = 4 if @options[:expand_tabs].negative?
 
     @options[:output] ||= $stdout
 
     @options[:css] ||= DEFAULT_CSS.dup
 
-    @options[:title] ||= "diff"
+    @options[:title] ||= 'diff'
   end
   private :verify_options
 
@@ -111,16 +112,16 @@ h1 { margin-left: 2em; }
   def run
     verify_options
 
-    if @options[:expand_tabs] > 0 && self.class.can_expand_tabs
+    if @options[:expand_tabs].positive? && self.class.can_expand_tabs
       formatter = Text::Format.new
       formatter.tabstop = @options[:expand_tabs]
 
-      @left.map! { |line| formatter.expand(line.chomp) }
-      @right.map! { |line| formatter.expand(line.chomp) }
+      @left.map! do |line| formatter.expand(line.chomp) end
+      @right.map! do |line| formatter.expand(line.chomp) end
     end
 
-    @left.map! { |line| CGI.escapeHTML(line.chomp) }
-    @right.map! { |line| CGI.escapeHTML(line.chomp) }
+    @left.map! do |line| CGI.escapeHTML(line.chomp) end
+    @right.map! do |line| CGI.escapeHTML(line.chomp) end
 
     @options[:output] << <<-OUTPUT
 <html>

data/lib/diff/lcs/hunk.rb

@@ -1,30 +1,43 @@
-# -*- ruby encoding: utf-8 -*-
+# frozen_string_literal: true
 
 require 'diff/lcs/block'
 
-# A Hunk is a group of Blocks which overlap because of the context
-# surrounding each block. (So if we're not using context, every hunk will
-# contain one block.) Used in the diff program (bin/diff).
+# A Hunk is a group of Blocks which overlap because of the context surrounding
+# each block. (So if we're not using context, every hunk will contain one
+# block.) Used in the diff program (bin/ldiff).
 class Diff::LCS::Hunk
-  # Create a hunk using references to both the old and new data, as well as
-  # the piece of data.
+  OLD_DIFF_OP_ACTION = { '+' => 'a', '-' => 'd', '!' => 'c' }.freeze #:nodoc:
+  ED_DIFF_OP_ACTION = { '+' => 'a', '-' => 'd', '!' => 'c' }.freeze #:nodoc:
+
+  private_constant :OLD_DIFF_OP_ACTION, :ED_DIFF_OP_ACTION if respond_to?(:private_constant)
+
+  # Create a hunk using references to both the old and new data, as well as the
+  # 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) ]
+    @blocks = [Diff::LCS::Block.new(piece)]
+
+    if @blocks[0].remove.empty? && @blocks[0].insert.empty?
+      fail "Cannot build a hunk from #{piece.inspect}; has no add or remove actions"
+    end
+
     if String.method_defined?(:encoding)
-      @preferred_data_encoding = data_old.fetch(0, data_new.fetch(0,'') ).encoding
+      @preferred_data_encoding = data_old.fetch(0, data_new.fetch(0, '')).encoding
     end
+
     @data_old = data_old
     @data_new = data_new
 
     before = after = file_length_difference
     after += @blocks[0].diff_size
     @file_length_difference = after # The caller must get this manually
+    @max_diff_size = @blocks.map { |e| e.diff_size.abs }.max
+
 
     # Save the start & end of each array. If the array doesn't exist (e.g.,
-    # 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.
+    # 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?
       a1 = a2 = nil
     else
@@ -54,20 +67,27 @@ class Diff::LCS::Hunk
 
   # Change the "start" and "end" fields to note that context should be added
   # to this hunk.
-  attr_accessor :flag_context
-  undef :flag_context=;
-  def flag_context=(context) #:nodoc:
+  attr_accessor :flag_context # rubocop:disable Layout/EmptyLinesAroundAttributeAccessor
+  undef :flag_context=
+  def flag_context=(context) #:nodoc: # rubocop:disable Lint/DuplicateMethods
     return if context.nil? or context.zero?
 
-    add_start = (context > @start_old) ? @start_old : context
+    add_start = context > @start_old ? @start_old : context
+
     @start_old -= add_start
     @start_new -= add_start
 
-    if (@end_old + context) > @data_old.size
-      add_end = @data_old.size - @end_old
-    else
-      add_end = context
-    end
+    old_size = @data_old.size
+
+    add_end =
+      if (@end_old + context) > old_size
+        old_size - @end_old
+      else
+        context
+      end
+
+    add_end = @max_diff_size if add_end >= old_size
+
     @end_old += add_end
     @end_new += add_end
   end
@@ -76,15 +96,13 @@ class Diff::LCS::Hunk
   # a truthy value so that if there is no overlap, you can know the merge
   # was skipped.
   def merge(hunk)
-    if overlaps?(hunk)
-      @start_old = hunk.start_old
-      @start_new = hunk.start_new
-      blocks.unshift(*hunk.blocks)
-    else
-      nil
-    end
+    return unless overlaps?(hunk)
+
+    @start_old = hunk.start_old
+    @start_new = hunk.start_new
+    blocks.unshift(*hunk.blocks)
   end
-  alias_method :unshift, :merge
+  alias unshift merge
 
   # Determines whether there is an overlap between this hunk and the
   # provided hunk. This will be true if the difference between the two hunks
@@ -95,47 +113,53 @@ class Diff::LCS::Hunk
   end
 
   # Returns a diff string based on a format.
-  def diff(format)
+  def diff(format, last = false)
     case format
     when :old
-      old_diff
+      old_diff(last)
     when :unified
-      unified_diff
+      unified_diff(last)
     when :context
-      context_diff
+      context_diff(last)
     when :ed
       self
     when :reverse_ed, :ed_finish
-      ed_diff(format)
+      ed_diff(format, last)
     else
-      raise "Unknown diff format #{format}."
+      fail "Unknown diff format #{format}."
     end
   end
 
   # Note that an old diff can't have any context. Therefore, we know that
   # there's only one block in the hunk.
-  def old_diff
-    warn "Expecting only one block in an old diff hunk!" if @blocks.size > 1
-    op_act = { "+" => 'a', "-" => 'd', "!" => "c" }
+  def old_diff(_last = false)
+    warn 'Expecting only one block in an old diff hunk!' if @blocks.size > 1
 
     block = @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
     # them.
-    s = encode("#{context_range(:old)}#{op_act[block.op]}#{context_range(:new)}\n")
+    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.
-    @data_old[@start_old .. @end_old].each { |e| s << encode("< ") + e + encode("\n") } unless block.remove.empty?
-    s << encode("---\n") if block.op == "!"
-    @data_new[@start_new .. @end_new].each { |e| s << encode("> ") + e + encode("\n") } unless block.insert.empty?
+    unless 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?
+      @data_new[@start_new..@end_new].each { |e| s << encode('> ') + e.chomp + encode("\n") }
+    end
+
     s
   end
   private :old_diff
 
-  def unified_diff
+  def unified_diff(last = false)
     # Calculate item number range.
-    s = encode("@@ -#{unified_range(:old)} +#{unified_range(:new)} @@\n")
+    s = encode("@@ -#{unified_range(:old, last)} +#{unified_range(:new, last)} @@\n")
 
     # Outlist starts containing the hunk of the old file. Removing an item
     # just means putting a '-' in front of it. Inserting an item requires
@@ -148,7 +172,14 @@ class Diff::LCS::Hunk
     # file -- don't take removed items into account.
     lo, hi, num_added, num_removed = @start_old, @end_old, 0, 0
 
-    outlist = @data_old[lo .. hi].map { |e| e.insert(0, encode(' ')) }
+    outlist = @data_old[lo..hi].map { |e| String.new("#{encode(' ')}#{e.chomp}") }
+
+    last_block = blocks[-1]
+
+    if last
+      old_missing_newline = missing_last_newline?(@data_old)
+      new_missing_newline = missing_last_newline?(@data_new)
+    end
 
     @blocks.each do |block|
       block.remove.each do |item|
@@ -157,66 +188,100 @@ class Diff::LCS::Hunk
         outlist[offset][0, 1] = encode(op)
         num_removed += 1
       end
+
+      if last && block == last_block && old_missing_newline && !new_missing_newline
+        outlist << encode('\')
+        num_removed += 1
+      end
+
       block.insert.each do |item|
         op     = item.action.to_s # +
         offset = item.position - @start_new + num_removed
-        outlist[offset, 0] = encode(op) + @data_new[item.position]
+        outlist[offset, 0] = encode(op) + @data_new[item.position].chomp
         num_added += 1
       end
     end
 
+    outlist << encode('\') if last && new_missing_newline
+
     s << outlist.join(encode("\n"))
+
+    s
   end
   private :unified_diff
 
-  def context_diff
+  def context_diff(last = false)
     s = encode("***************\n")
-    s << encode("*** #{context_range(:old)} ****\n")
-    r = context_range(:new)
+    s << encode("*** #{context_range(:old, ',', last)} ****\n")
+    r = context_range(:new, ',', last)
+
+    if last
+      old_missing_newline = missing_last_newline?(@data_old)
+      new_missing_newline = missing_last_newline?(@data_new)
+    end
 
     # Print out file 1 part for each block in context diff format if there
     # are any blocks that remove items
     lo, hi = @start_old, @end_old
-    removes = @blocks.select { |e| not e.remove.empty? }
-    if removes
-      outlist = @data_old[lo .. hi].map { |e| e.insert(0, encode(' ')) }
+    removes = @blocks.reject { |e| e.remove.empty? }
+
+    unless removes.empty?
+      outlist = @data_old[lo..hi].map { |e| String.new("#{encode('  ')}#{e.chomp}") }
+
+      last_block = removes[-1]
 
       removes.each do |block|
         block.remove.each do |item|
           outlist[item.position - lo][0, 1] = encode(block.op) # - or !
         end
+
+        if last && block == last_block && old_missing_newline
+          outlist << encode('\')
+        end
       end
-      s << outlist.join("\n")
+
+      s << outlist.join(encode("\n")) << encode("\n")
     end
 
-    s << encode("\n--- #{r} ----\n")
+    s << encode("--- #{r} ----\n")
     lo, hi = @start_new, @end_new
-    inserts = @blocks.select { |e| not e.insert.empty? }
-    if inserts
-      outlist = @data_new[lo .. hi].collect { |e| e.insert(0, encode(' ')) }
+    inserts = @blocks.reject { |e| e.insert.empty? }
+
+    unless inserts.empty?
+      outlist = @data_new[lo..hi].map { |e| String.new("#{encode('  ')}#{e.chomp}") }
+
+      last_block = inserts[-1]
+
       inserts.each do |block|
         block.insert.each do |item|
           outlist[item.position - lo][0, 1] = encode(block.op) # + or !
         end
+
+        if last && block == last_block && new_missing_newline
+          outlist << encode('\')
+        end
       end
-      s << outlist.join("\n")
+      s << outlist.join(encode("\n"))
     end
+
     s
   end
   private :context_diff
 
-  def ed_diff(format)
-    op_act = { "+" => 'a', "-" => 'd', "!" => "c" }
-    warn "Expecting only one block in an old diff hunk!" if @blocks.size > 1
+  def ed_diff(format, _last = false)
+    warn 'Expecting only one block in an old diff hunk!' if @blocks.size > 1
 
-    if format == :reverse_ed
-      s = encode("#{op_act[@blocks[0].op]}#{context_range(:old)}\n")
-    else
-      s = encode("#{context_range(:old, ' ')}#{op_act[@blocks[0].op]}\n")
-    end
+    s =
+      if format == :reverse_ed
+        encode("#{ED_DIFF_OP_ACTION[@blocks[0].op]}#{context_range(:old, ',')}\n")
+      else
+        encode("#{context_range(:old, ' ')}#{ED_DIFF_OP_ACTION[@blocks[0].op]}\n")
+      end
 
     unless @blocks[0].insert.empty?
-      @data_new[@start_new .. @end_new].each { |e| s << e + encode("\n") }
+      @data_new[@start_new..@end_new].each do |e|
+        s << e.chomp + encode("\n")
+      end
       s << encode(".\n")
     end
     s
@@ -225,7 +290,7 @@ class Diff::LCS::Hunk
 
   # Generate a range of item numbers to print. Only print 1 number if the
   # range has only one item in it. Otherwise, it's 'start,end'
-  def context_range(mode, op = ',')
+  def context_range(mode, op, last = false)
     case mode
     when :old
       s, e = (@start_old + 1), (@end_old + 1)
@@ -233,14 +298,17 @@ class Diff::LCS::Hunk
       s, e = (@start_new + 1), (@end_new + 1)
     end
 
-    (s < e) ? "#{s}#{op}#{e}" : "#{e}"
+    e -= 1 if last
+    e = 1 if e.zero?
+
+    s < e ? "#{s}#{op}#{e}" : e.to_s
   end
   private :context_range
 
   # Generate a range of item numbers to print for unified diff. Print number
   # where block starts, followed by number of lines in the block
   # (don't print number of lines if it's 1)
-  def unified_range(mode)
+  def unified_range(mode, last)
     case mode
     when :old
       s, e = (@start_old + 1), (@end_old + 1)
@@ -248,12 +316,25 @@ class Diff::LCS::Hunk
       s, e = (@start_new + 1), (@end_new + 1)
     end
 
-    length = e - s + 1
-    first = (length < 2) ? e : s # "strange, but correct"
-    (length == 1) ? "#{first}" : "#{first},#{length}"
+    length = e - s + (last ? 0 : 1)
+
+    first = length < 2 ? e : s # "strange, but correct"
+    length <= 1 ? first.to_s : "#{first},#{length}"
   end
   private :unified_range
 
+  def missing_last_newline?(data)
+    newline = encode("\n")
+
+    if data[-2]
+      data[-2].end_with?(newline) && !data[-1].end_with?(newline)
+    elsif data[-1]
+      !data[-1].end_with?(newline)
+    else
+      true
+    end
+  end
+
   if String.method_defined?(:encoding)
     def encode(literal, target_encoding = @preferred_data_encoding)
       literal.encode target_encoding
@@ -263,10 +344,11 @@ class Diff::LCS::Hunk
       args.map { |arg| arg.encode(string.encoding) }
     end
   else
-    def encode(literal, target_encoding = nil)
+    def encode(literal, _target_encoding = nil)
       literal
     end
-    def encode_as(string, *args)
+
+    def encode_as(_string, *args)
       args
     end
   end