riffdiff 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d5898446e7539cc53b995c89422d06926fe837ed
+  data.tar.gz: 9d0f0b66dccb850b5eb801daa9cf10275081673a
+SHA512:
+  metadata.gz: 638ec5d15529d20ba6e65962a892fcb386b3c6cfd3c8e7c141678bc3743e7da317d071d1fff77422238990251d264922e3641e52597c400b23a024f389564c53
+  data.tar.gz: 2a078dbacd85fd198ac49ca8e122e626db3e8aac662b6a5bc6da6070dbbcdc36a2e0870737e82b517ed182fe781e943c6c9b12990ca8e09e9beef1b0a0d7ccec

data/.bundle/config

@@ -0,0 +1,2 @@
+---
+BUNDLE_BIN: bin

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/.rubocop.yml

@@ -0,0 +1,26 @@
+# This configuration was generated by `rubocop --auto-gen-config`
+# on 2015-03-27 21:35:37 +0100 using RuboCop version 0.29.1.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# I *like* these parentheses, kill the warnings /johan.walles@gmail.com
+Style/MethodCallParentheses:
+  Enabled: false
+Style/DefWithParentheses:
+  Enabled: false
+
+# Johan doesn't like the single-line form of if()
+Style/IfUnlessModifier:
+  Enabled: false
+Style/GuardClause:
+  Enabled: false
+
+# Johan thinks return statements improve readability
+Style/RedundantReturn:
+  Enabled: false
+
+# Johan thinks these are OK as long as there aren't too many of them
+Style/PerlBackrefs:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem 'rspec', '~> 3.0'
+gem 'diff-lcs', '~> 1.2.5'
+gem 'slop', '~> 4.1.0'

data/Gemfile.lock

@@ -0,0 +1,26 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    rspec (3.2.0)
+      rspec-core (~> 3.2.0)
+      rspec-expectations (~> 3.2.0)
+      rspec-mocks (~> 3.2.0)
+    rspec-core (3.2.2)
+      rspec-support (~> 3.2.0)
+    rspec-expectations (3.2.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-mocks (3.2.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.2.0)
+    rspec-support (3.2.2)
+    slop (4.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  diff-lcs (~> 1.2.5)
+  rspec (~> 3.0)
+  slop (~> 4.1.0)

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Johan Walles
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/README.md

@@ -0,0 +1,100 @@
+# Riff, the Refining Diff
+Riff is a wrapper around diff that highlights not only which lines
+have changed, but also which parts of the lines that have changed.
+
+# Usage
+    git diff | riff
+
+Or if you do...
+
+    git config --global pager.diff riff
+    git config --global pager.show riff
+
+... then all future 'git diff's and 'git show's will be refined.
+
+# TODO before first release
+* Release version 0.0.0
+
+# TODO post first release
+* Think about how to visualize one line changing to itself with a
+  comma at the end plus a bunch of entirely new lines. Think of a
+  constant array getting one or more extra members.
+* Think about highlighting whitespace errors like Git does
+* Think about how to visualize an added line break together with some
+indentation on the following line.
+* Do "git show 57f27da" and think about what rule we should use to get
+the REVERSE vs reversed() lines highlighted.
+* Do "git show 2ac5b06" and think about what rule we should use to
+highlight all of both "some" and "one or".
+* Do "git show -b 77c8f77" and think about what rule we should use to
+  highlight the leading spaces of the "+  refined" and "+  page" lines
+  at the end of the file.
+* Make sure we highlight the output of "git log -p" properly. If we
+get something unexpected, maybe just go back to :initial?
+* Make sure we highlight the output of "git show --stat" properly
+* Make sure we can handle a git conflict
+  resolution diff. File format is described at
+  http://git-scm.com/docs/git-diff#_combined_diff_format.
+* Given two files on the command line, we should pass them and any
+options on to "diff" and highlight the result.
+* Given three files on the command line, we should pass them and any
+options on to "diff3" and highlight the result
+
+# TODO future
+* Detect moved blocks and use a number as a prefix for both the add
+  and the remove part of the move. Hightlight any changes just like
+  for other changes.
+
+# DONE
+* Make a main program that can read input from stdin and print it to
+stdout.
+* Make the main program identify different kinds of lines by prefix
+and color them accordingly. Use the same color scheme as `git`.
+* Make the main program identify blocks of lines that have been
+replaced by another block of lines.
+* Use http://www.rubydoc.info/github/halostatue/diff-lcs rather
+than our own refinement algorithm
+* Make it possible to print rather than puts Refiner output
+* "print" rather than "puts" the Refiner output
+* Make the Refiner not highlight anything if either old or new is
+empty
+* Ask the Refiner even if either old or new is empty
+* Use DiffString for context lines
+* Preserve linefeeds when sending lines to the Refiner
+* All context lines must be prefixed by ' ', currently they aren't
+* Refine each pair of blocks, make sure both added characters and
+  removed characters are highlighted in a readable fashion, both in
+  added blocks and removed blocks.
+* Diffing <x "hej"> vs <x 'hej'> shows the first space as a
+difference.
+* If stdout is a terminal, pipe the output to a pager using the
+algorithm described under "core.pager" in "git help config".
+* Do some effort to prevent fork loops if people set riff as $PAGER
+* Make the Refiner not highlight anything if there are "too many"
+differences between the sections. The point here is that we want to
+highlight changes, but if it's a *replacement* rather than a change
+then we don't want to highlight it.
+* Refine added line endings properly
+* Refine removed line endings properly
+* Refine "ax"->"bx\nc" properly
+* Strip all color from the input before handling it to enable users to
+  set Git's pager.diff and pager.show variables to 'riff' without also
+  needing to set color.diff=false.
+* Visualize removed linefeed at end of file properly
+* Visualize adding a missing linefeed at end of file properly
+* Visualize missing linefeed at end of file as part of the context
+properly
+* On exceptions, print the riff.rb @state
+* On exceptions, print the line riff.rb was processing
+* On exceptions, print a link to the issue tracker
+* Add support for --help
+* Print help and bail if stdin is a terminal
+* Add support for --version
+* On exceptions, print the current version just like --version
+* Put an upper bound on how large regions we should attempt to refine
+* Find out how the LCS algorithm scales and improve the heuristic for
+  when not to call it.
+* You can do `git diff | riff` and get reasonable output.
+* Test that we work as expected when "gem install"ed system-wide
+* Create a Rakefile that can install dependencies, build, run tests, package and
+optionally deploy as well.

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rspec/core/rake_task'
+
+task default: :spec
+desc 'Run the unit tests (default)'
+task spec: [:deps]
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = FileList['spec/**/*_spec.rb']
+end
+
+desc 'Create a .gem package'
+task package: [:spec] do
+  system('rm -f *.gem ; gem build riffdiff.gemspec') || fail
+end
+
+desc 'Install dependencies'
+task :deps do
+  system('bundle install') || fail
+end
+
+desc 'Publish to rubygems.org'
+task publish: [:package] do
+  system('gem push *.gem') || fail
+end

data/bin/benchmark

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+
+# This program is for finding out how our refiner's performance scales
+# with the size of the input.
+
+# Inspired by http://timelessrepo.com/making-ruby-gems
+begin
+  require 'riff'
+rescue LoadError
+  $LOAD_PATH.unshift File.join(__dir__, '..', 'lib')
+  require 'riff'
+end
+
+$ks = {}
+def time_string(dt, m, n, formula)
+  k = dt / eval(formula)
+  $ks[formula] = k unless $ks.key? formula
+  k /= $ks[formula]
+  return "#{k.round(1)}: dt/(#{formula})"
+end
+
+$k0_a_plus_b = nil
+$k0_a_times_b = nil
+$k0_dist = nil
+def print_timings(old_size, new_size)
+  old = 'o' * old_size
+  new = 'n' * new_size
+  t0 = Time.now
+  Refiner.new(old, new)
+  t1 = Time.now
+  dt = t1 - t0
+
+  puts "Timings: old_size=#{old_size} new_size=#{new_size} dt=#{dt.round(1)}s"
+
+  puts "  #{time_string(dt, old_size, new_size, 'm+n')}"
+  puts "  #{time_string(dt, old_size, new_size, 'm*n*Math.log(m)')}"
+  puts "  #{time_string(dt, old_size, new_size, 'Math.sqrt(m*m + n*n)')}"
+  puts "  #{time_string(dt, old_size, new_size, 'Math.log(m*m + n*n)')}"
+  puts "  #{time_string(dt, old_size, new_size, 'Math.sqrt(m + n)')}"
+
+  puts
+end
+
+print_timings(40_000, 40_000)
+print_timings(40_000, 40_000)
+print_timings(40_000, 40_000)
+print_timings(40_000, 40_000)
+puts
+
+# Exercise O(m+n)
+print_timings(10, 79_990)
+
+# Exercise O(m*n)
+print_timings(20_000, 80_000)
+
+# Excercise m+n=15000
+print_timings(7_500, 7_500)
+
+# Excercise m+n=30000
+print_timings(15_000, 15_000)
+
+puts

data/bin/bundler

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'bundler' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('bundler', 'bundler')

data/bin/htmldiff

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'htmldiff' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('diff-lcs', 'htmldiff')

data/bin/ldiff

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'ldiff' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('diff-lcs', 'ldiff')

data/bin/riff

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+begin
+  # Inspired by http://timelessrepo.com/making-ruby-gems
+  begin
+    require 'riff'
+  rescue LoadError
+    $LOAD_PATH.unshift File.join(__dir__, '..', 'lib')
+    require 'riff'
+  end
+
+  require 'options'
+  include Options
+  handle_options
+
+  require 'pager'
+  include Pager
+
+  refined = Riff.new().do_stream(STDIN)
+  page(refined)
+rescue => e
+  STDERR.puts e.to_s
+  STDERR.puts e.backtrace.join("\n\t")
+  STDERR.puts
+  begin
+    STDERR.puts "Riff version #{version}"
+  rescue => e
+    STDERR.puts 'Also, getting the Riff version failed:'
+    STDERR.puts e.to_s
+    STDERR.puts e.backtrace.join("\n\t")
+  end
+  STDERR.puts
+  STDERR.puts 'Please report this to https://github.com/walles/riff/issues'
+end

data/bin/rspec

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile",
+  Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('rspec-core', 'rspec')

data/lib/colors.rb

@@ -0,0 +1,22 @@
+# ANSI Color related escape code constants
+module Colors
+  ESC = 27.chr
+
+  BOLD = "#{ESC}[1m"
+  CYAN = "#{ESC}[36m"
+  GREEN = "#{ESC}[32m"
+  RED = "#{ESC}[31m"
+
+  REVERSE = "#{ESC}[7m"
+  NOT_REVERSE = "#{ESC}[27m"
+
+  RESET = "#{ESC}[m"
+
+  def reversed(string)
+    return "#{REVERSE}#{string}#{NOT_REVERSE}"
+  end
+
+  def uncolor(string)
+    return string.gsub(/#{ESC}[^m]*m/, '')
+  end
+end

data/lib/diff_string.rb

@@ -0,0 +1,52 @@
+# coding: utf-8
+require 'colors'
+
+# An added or removed part of a diff, which can contain both
+# highlighted and not highlighted characters. For multi line strings,
+# each line will be prefixed with prefix and color.
+class DiffString
+  include Colors
+
+  def initialize(prefix, color)
+    @reverse = false
+    @prefix = prefix
+    @color = color
+    @string = ''
+  end
+
+  def add(string, reverse)
+    if reverse && string == "\n"
+      add('↵', true)
+      add("\n", false)
+      return
+    end
+
+    if @string.empty?() || @string.end_with?("\n")
+      @string += @color
+      @string += @prefix
+    end
+
+    if reverse != @reverse
+      @string += reverse ? REVERSE : NOT_REVERSE
+    end
+    @reverse = reverse
+
+    @string += string
+  end
+
+  def to_s()
+    return '' if @string.empty?
+
+    string = @string
+    string.chomp! if string.end_with? "\n"
+
+    suffix = @color.empty? ? '' : RESET
+    return string + suffix + "\n"
+  end
+
+  def self.decorate_string(prefix, color, string)
+    decorated = DiffString.new(prefix, color)
+    decorated.add(string, false)
+    return decorated.to_s
+  end
+end

data/lib/options.rb

@@ -0,0 +1,46 @@
+require 'slop'
+require 'version'
+
+# Handle command line options
+module Options
+  include Version
+
+  def handle_options
+    opts = Slop::Options.new do |o|
+      o.banner = <<-EOS
+Usage: diff ... | riff
+Colors diff and highlights what parts of changed lines have changed.
+
+Git integration:
+    git config --global pager.diff riff
+    git config --global pager.show riff
+EOS
+      o.separator 'Options:'
+      o.on '--version', 'Print version information and exit' do
+        puts "riff #{version}"
+        puts
+        puts 'Developed at http://github.com/walles/riff'
+
+        exit
+      end
+      o.on '-h', '--help', 'Print this help' do
+        puts o
+        exit
+      end
+    end
+
+    begin
+      opts.parse(ARGV)
+    rescue Slop::Error => e
+      STDERR.puts "ERROR: #{e}"
+      STDERR.puts
+      STDERR.puts opts
+      exit 1
+    end
+
+    if $stdin.isatty
+      puts opts
+      exit
+    end
+  end
+end

data/lib/pager.rb

@@ -0,0 +1,51 @@
+# Add a pager() method that can send text to a pager.
+#
+# With "pager" referring to something like less or moar.
+#
+# This file attempts to be as close as possible to what Git is
+# doing. For reference, do "git help config", search for "core.pager"
+# and compare that text to the page() method below.
+module Pager
+  # Checking for this variable before launching $PAGER should prevent
+  # us from fork bombing if somebody sets the PAGER environment
+  # variable to point to us.
+  DONT_USE_PAGER_VAR = '_RIFF_PREVENT_PAGING_LOOP'
+
+  def pipe_text_into_command(text, command)
+    env = {
+      DONT_USE_PAGER_VAR => '1'
+    }
+
+    # Set LESS=FRX unless $LESS already has a value
+    env['LESS'] = 'FRX' unless ENV['LESS']
+
+    # Set LV=-c unless $LV already has a value
+    env['LV'] = '-c' unless ENV['LV']
+
+    IO.popen(env, command, 'w') { |pager| pager.print text }
+  end
+
+  def less(text)
+    pipe_text_into_command(text, 'less')
+  end
+
+  # If $DONT_USE_PAGER_VAR is set, we shouldn't use $PAGER
+  def dont_use_pager?
+    return true if ENV[DONT_USE_PAGER_VAR]
+    return true if ENV['PAGER'].nil?
+    return true if ENV['PAGER'].empty?
+    return false
+  end
+
+  def page(text)
+    if !$stdout.isatty
+      print text
+    elsif dont_use_pager?
+      less(text)
+    elsif ENV['PAGER']
+      pipe_text_into_command(text, ENV['PAGER'])
+    else
+      less(text)
+    end
+  end
+end

data/lib/refiner.rb

@@ -0,0 +1,86 @@
+require 'set'
+require 'diff/lcs'
+require 'diff_string'
+
+# Compute longest common substring based diff between two strings.
+#
+# The diff format is first the old string:
+# * in red
+# * with each line prefixed with minuses
+# * removed characters highlighted in inverse video
+#
+# Then comes the new string:
+# * in green
+# * with each line prefixed with plusses
+# * added characters highlighted in inverse video
+class Refiner
+  include Colors
+
+  attr_reader :refined_old
+  attr_reader :refined_new
+
+  # If either old or new would get more than this percentage of chars
+  # highlighted, consider this to be a replacement rather than a
+  # change and just don't highlight anything.
+  REFINEMENT_THRESHOLD = 30
+
+  def collect_highlights(diff, old_highlights, new_highlights)
+    diff.each do |section|
+      section.each do |highlight|
+        case highlight.action
+        when '-'
+          old_highlights << highlight.position
+        when '+'
+          new_highlights << highlight.position
+        else
+          fail("Unsupported diff type: <#{type}>")
+        end
+      end
+    end
+  end
+
+  def censor_highlights(old, new, old_highlights, new_highlights)
+    old_highlights_percentage = 100 * old_highlights.size / old.length
+    new_highlights_percentage = 100 * new_highlights.size / new.length
+
+    if old_highlights_percentage > REFINEMENT_THRESHOLD \
+       || new_highlights_percentage > REFINEMENT_THRESHOLD
+      # We'll consider this a replacement rather than a change, don't
+      # highlight it.
+      old_highlights.clear
+      new_highlights.clear
+    end
+  end
+
+  def should_highlight?(old, new)
+    return false if old.empty? || new.empty?
+
+    # The 15_000 constant has been determined using the "benchmark"
+    # program in our bin/ directory.
+    return false if old.length + new.length > 15_000
+
+    return true
+  end
+
+  def initialize(old, new)
+    old_highlights = Set.new
+    new_highlights = Set.new
+    if should_highlight?(old, new)
+      collect_highlights(Diff::LCS.diff(old, new),
+                         old_highlights,
+                         new_highlights)
+
+      censor_highlights(old, new, old_highlights, new_highlights)
+    end
+
+    @refined_old = DiffString.new('-', RED)
+    old.each_char.with_index do |char, index|
+      @refined_old.add(char, old_highlights.include?(index))
+    end
+
+    @refined_new = DiffString.new('+', GREEN)
+    new.each_char.with_index do |char, index|
+      @refined_new.add(char, new_highlights.include?(index))
+    end
+  end
+end

data/lib/riff.rb

@@ -0,0 +1,171 @@
+require 'colors'
+require 'refiner'
+require 'diff_string'
+
+# Call do_stream() with the output of some diff-like tool (diff,
+# diff3, git diff, ...) and it will highlight that output for you.
+class Riff
+  DIFF_HEADER = /^diff /
+  DIFF_HUNK_HEADER = /^@@ /
+
+  DIFF_ADDED = /^\+(.*)/
+  DIFF_REMOVED = /^-(.*)/
+  DIFF_CONTEXT = /^ /
+  DIFF_NO_ENDING_NEWLINE = /^\\/
+
+  include Colors
+
+  LINE_PREFIX = {
+    initial:          '',
+    diff_header:      BOLD,
+    diff_hunk_header: CYAN,
+    diff_hunk:        '',
+    diff_added:       GREEN,
+    diff_removed:     RED,
+    diff_context:     '',
+    diff_no_ending_newline: ''
+  }
+
+  def initialize()
+    @state = :initial
+
+    @replace_old = ''
+    @replace_new = ''
+  end
+
+  def handle_initial_line(line)
+    if line =~ DIFF_HEADER
+      @state = :diff_header
+    end
+  end
+
+  def handle_diff_header_line(line)
+    if line =~ DIFF_HUNK_HEADER
+      @state = :diff_hunk_header
+    end
+  end
+
+  def handle_diff_hunk_header_line(line)
+    handle_diff_hunk_line(line)
+  end
+
+  def handle_no_ending_newline(line)
+    case @state
+    when :diff_added
+      @replace_new.sub!(/\n$/, '')
+    when :diff_removed
+      @replace_old.sub!(/\n$/, '')
+    when :diff_context
+      # Intentionally ignored
+      return
+    else
+      fail NotImplementedError,
+           "Can't handle no-ending-newline in <#{@state}> line: <#{line}>"
+    end
+
+    @state = :diff_no_ending_newline
+  end
+
+  def handle_diff_hunk_line(line)
+    case line
+    when DIFF_HUNK_HEADER
+      @state = :diff_hunk_header
+    when DIFF_HEADER
+      @state = :diff_header
+    when DIFF_ADDED
+      @state = :diff_added
+    when DIFF_REMOVED
+      @state = :diff_removed
+    when DIFF_CONTEXT
+      @state = :diff_context
+    when DIFF_NO_ENDING_NEWLINE
+      handle_no_ending_newline(line)
+    else
+      fail NotImplementedError, "Can't handle <#{@state}> line: <#{line}>"
+    end
+  end
+
+  def handle_diff_added_line(line)
+    handle_diff_hunk_line(line)
+  end
+
+  def handle_diff_removed_line(line)
+    handle_diff_hunk_line(line)
+  end
+
+  def handle_diff_context_line(line)
+    handle_diff_hunk_line(line)
+  end
+
+  def handle_diff_no_ending_newline_line(line)
+    handle_diff_hunk_line(line)
+  end
+
+  # If we have stored adds / removes, calling this method will flush
+  # those.
+  def consume_replacement()
+    return '' if @replace_old.empty? && @replace_new.empty?
+
+    refiner = Refiner.new(@replace_old, @replace_new)
+    return_me = refiner.refined_old.to_s
+    return_me += refiner.refined_new.to_s
+
+    @replace_old = ''
+    @replace_new = ''
+
+    return return_me
+  end
+
+  # Call handle_<state>_line() for the given state and line
+  def handle_line_for_state(state, line)
+    method_name = "handle_#{state}_line"
+    fail "Unknown state: <:#{state}>" unless
+      self.respond_to? method_name
+
+    send(method_name, line)
+  end
+
+  def handle_diff_line(line)
+    line.chomp!
+    line = uncolor(line)
+
+    handle_line_for_state(@state, line)
+
+    case @state
+    when :diff_added
+      @replace_new += DIFF_ADDED.match(line)[1] + "\n"
+      return ''
+    when :diff_removed
+      @replace_old += DIFF_REMOVED.match(line)[1] + "\n"
+      return ''
+    when :diff_no_ending_newline
+      return ''
+    else
+      refined = consume_replacement()
+
+      color = LINE_PREFIX.fetch(@state)
+
+      return refined + DiffString.decorate_string('', color, line + "\n")
+    end
+  end
+
+  # Read diff from a stream and output a highlighted version to stdout
+  def do_stream(diff_stream)
+    output = ''
+    current_line = nil
+
+    begin
+      diff_stream.each do |line|
+        current_line = line
+        output += handle_diff_line(line)
+      end
+      output += consume_replacement()
+    rescue
+      STDERR.puts "State: <#{@state}>"
+      STDERR.puts "Current line: <#{current_line}>"
+      raise
+    end
+
+    return output
+  end
+end

data/lib/version.rb

@@ -0,0 +1,39 @@
+require 'English'
+
+# Methods for finding out the Riff version
+module Version
+  def git_version
+    version = `cd #{__dir__} ; git describe --dirty 2> /dev/null`.chomp
+    if $CHILD_STATUS.success?
+      return version
+    else
+      return nil
+    end
+  end
+
+  def rubygems_version
+    return Gem::Specification.find_by_name('riffdiff').version.to_s
+  end
+
+  # Turn git describe output into a semantic version, inspired by riff.gemspec
+  def semantify_git_version(raw)
+    return nil if raw.nil?
+
+    return raw if raw.end_with? '-dirty'
+
+    return (raw + '.0') if /^[0-9]+\.[0-9]+$/.match(raw)
+
+    if /^([0-9]+\.[0-9]+)-([0-9]+)-/.match(raw)
+      return "#{$1}.#{$2}"
+    end
+
+    return raw
+  end
+
+  def version
+    semantic_git_version = semantify_git_version(git_version)
+    return semantic_git_version unless semantic_git_version.nil?
+
+    return rubygems_version
+  end
+end

data/riffdiff.gemspec

@@ -0,0 +1,19 @@
+$LOAD_PATH.unshift File.join(File.absolute_path(__dir__), 'lib')
+require 'version'
+
+Gem::Specification.new do |s|
+  extend Version
+
+  s.name        = 'riffdiff'
+  s.version     = semantify_git_version(git_version)
+  s.summary     = 'A diff highlighter showing what parts of lines have changed'
+  s.authors     = ['Johan Walles']
+  s.email       = 'johan.walles@gmail.com'
+  s.homepage    = 'http://github.com/walles/riff'
+  s.license     = 'MIT'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = ['riff']
+  s.require_paths = ['lib']
+end

data/spec/added-newline-at-eof.diff

@@ -0,0 +1,11 @@
+diff --git a/README.md b/README.md
+index bb8be87..950ec73 100644
+--- a/README.md
++++ b/README.md
+@@ -79,4 +79,4 @@ then we don't want to highlight it.
+ * Refine "ax"->"bx\nc" properly
+ * Strip all color from the input before handling it to enable users to
+   set Git's pager.diff and pager.show variables to 'riff' without also
+-  needing to set color.diff=false.
+
++  needing to set color.diff=false.

data/spec/colors_spec.rb

@@ -0,0 +1,35 @@
+# coding: utf-8
+require 'colors'
+
+include Colors
+
+RSpec.describe Colors, '#uncolor' do
+  context 'string with no colors' do
+    not_colored = 'not colored'
+
+    it 'does not change the contents' do
+      expect(uncolor(not_colored)).to eq(not_colored)
+    end
+  end
+
+  context 'all our codes' do
+    [BOLD, CYAN, GREEN, RED, REVERSE, NOT_REVERSE, RESET].each do |code|
+      printable_code = code.gsub(ESC, '\e')
+      it "can remove #{printable_code} by itself" do
+        expect(uncolor(code)).to eq('')
+      end
+
+      it "can remove #{printable_code} from the start of the string" do
+        expect(uncolor("#{code}foo")).to eq('foo')
+      end
+
+      it "can remove #{printable_code} from the end of the string" do
+        expect(uncolor("bar#{code}")).to eq('bar')
+      end
+
+      it "can remove #{printable_code} from the middle of the string" do
+        expect(uncolor("hej#{code}san")).to eq('hejsan')
+      end
+    end
+  end
+end

data/spec/diff_string_spec.rb

@@ -0,0 +1,91 @@
+# coding: utf-8
+require 'colors'
+require 'diff_string'
+
+include Colors
+
+RSpec.describe DiffString, '#add' do
+  context 'first and last highlighted' do
+    it 'renders correctly with one char in between' do
+      diff_string = DiffString.new('+', GREEN)
+      diff_string.add('1', true)
+      diff_string.add('2', false)
+      diff_string.add('3', true)
+      diff_string.add("\n", false)
+      expect(diff_string.to_s).to eq(
+        "#{GREEN}+#{reversed('1')}2#{reversed('3')}#{RESET}\n")
+    end
+
+    it 'renders correctly with a few chars in between' do
+      diff_string = DiffString.new('+', GREEN)
+      diff_string.add('1', true)
+      diff_string.add('2', false)
+      diff_string.add('3', false)
+      diff_string.add('4', false)
+      diff_string.add('5', true)
+      diff_string.add("\n", false)
+      expect(diff_string.to_s).to eq(
+        "#{GREEN}+#{reversed('1')}234#{reversed('5')}#{RESET}\n")
+    end
+  end
+
+  context 'multiline' do
+    it 'colors both lines' do
+      diff_string = DiffString.new('+', GREEN)
+      diff_string.add('a', false)
+      diff_string.add("\n", false)
+      diff_string.add('b', false)
+      diff_string.add("\n", false)
+
+      expect(diff_string.to_s).to eq(
+        "#{GREEN}+a\n" \
+        "#{GREEN}+b#{RESET}\n")
+    end
+  end
+
+  context %(with added newline) do
+    diff_string = DiffString.new('+', GREEN)
+    diff_string.add('a', false)
+    diff_string.add('b', false)
+    diff_string.add("\n", true)
+    diff_string.add('c', false)
+    diff_string.add('d', false)
+    diff_string.add("\n", false)
+
+    it %(properly highlights the newline) do
+      expect(diff_string.to_s).to eq(
+        %(#{GREEN}+ab#{reversed('↵')}\n) +
+        %(#{GREEN}+cd#{RESET}\n))
+    end
+  end
+
+  context %(with highlighted ending newline) do
+    diff_string = DiffString.new('+', GREEN)
+    diff_string.add('x', false)
+    diff_string.add('y', false)
+    diff_string.add("\n", true)
+
+    it %(properly highlights the newline) do
+      expect(diff_string.to_s).to eq(
+        %(#{GREEN}+xy#{reversed('↵')}#{RESET}\n))
+    end
+  end
+
+  context %(empty) do
+    diff_string = DiffString.new('+', GREEN)
+
+    it %(is empty) do
+      expect(diff_string.to_s).to eq('')
+    end
+  end
+
+  context %(doesn't end in a newline) do
+    diff_string = DiffString.new('+', GREEN)
+    diff_string.add('x', false)
+
+    it %(gets a newline added) do
+      expect(diff_string.to_s).to eq(
+        %(#{GREEN}+x#{RESET}\n))
+    end
+  end
+end

data/spec/no-newline-at-eof-context.diff

@@ -0,0 +1,12 @@
+diff --git a/README.md b/README.md
+index bb8be87..0769058 100644
+--- a/README.md
++++ b/README.md
+@@ -78,5 +78,5 @@ then we don't want to highlight it.
+ * Refine removed line endings properly
+ * Refine "ax"->"bx\nc" properly
+ * Strip all color from the input before handling it to enable users to
+-  set Git's pager.diff and pager.show variables to 'riff' without also
++  set Git's pager.diff and pager.xshow variables to 'riff' without also
+   needing to set color.diff=false.
+

data/spec/refiner_spec.rb

@@ -0,0 +1,117 @@
+# coding: utf-8
+require 'colors'
+require 'refiner'
+
+include Colors
+
+RSpec.describe Refiner, '#new' do
+  context 'with single quotes to double quotes' do
+    refiner = Refiner.new(%('quoted'\n), %("quoted"\n))
+
+    it 'highlights the quotes and nothing else' do
+      expect(refiner.refined_old.to_s).to eq(
+        %(#{RED}-#{reversed("'")}quoted#{reversed("'")}#{RESET}\n))
+      expect(refiner.refined_new.to_s).to eq(
+        %(#{GREEN}+#{reversed('"')}quoted#{reversed('"')}#{RESET}\n))
+    end
+  end
+
+  context 'with empty old' do
+    refiner = Refiner.new('', "something\n")
+
+    it 'refines old to the empty string' do
+      expect(refiner.refined_old.to_s).to eq('')
+    end
+
+    it 'does not highlight anything in new' do
+      expect(refiner.refined_new.to_s).to eq(
+        %(#{GREEN}+something#{RESET}\n))
+    end
+  end
+
+  context 'with empty new' do
+    refiner = Refiner.new("something\n", '')
+
+    it 'does not highlight anything in old' do
+      expect(refiner.refined_old.to_s).to eq(
+        %(#{RED}-something#{RESET}\n))
+    end
+
+    it 'refines new to the empty string' do
+      expect(refiner.refined_new.to_s).to eq('')
+    end
+  end
+
+  context %(with <x "hej"> to <x 'hej'>) do
+    refiner = Refiner.new(%(x "hej"\n), %(x 'hej'\n))
+
+    it 'highlights the quotes and nothing else' do
+      expect(refiner.refined_old.to_s).to eq(
+        %(#{RED}-x #{reversed('"')}hej#{reversed('"')}#{RESET}\n))
+      expect(refiner.refined_new.to_s).to eq(
+        %(#{GREEN}+x #{reversed("'")}hej#{reversed("'")}#{RESET}\n))
+    end
+  end
+
+  context %(with too many differences) do
+    refiner = Refiner.new("0123456789\n",
+                          "abcdefghij\n")
+
+    it %(doesn't highlight anything) do
+      expect(refiner.refined_old.to_s).to eq(
+        %(#{RED}-0123456789#{RESET}\n))
+      expect(refiner.refined_new.to_s).to eq(
+        %(#{GREEN}+abcdefghij#{RESET}\n))
+    end
+  end
+
+  context %(with added ending newline) do
+    refiner = Refiner.new('abcde',
+                          "abcde\n")
+
+    it %(highlights the newline) do
+      expect(refiner.refined_old.to_s).to eq(
+        %(#{RED}-abcde#{RESET}\n))
+      expect(refiner.refined_new.to_s).to eq(
+        %(#{GREEN}+abcde#{reversed('↵')}#{RESET}\n))
+    end
+
+    it %(ends in a newline) do
+      expect(refiner.refined_old.to_s).to end_with("\n")
+      expect(refiner.refined_new.to_s).to end_with("\n")
+    end
+  end
+
+  context %(with removed ending newline) do
+    refiner = Refiner.new("abcde\n",
+                          'abcde')
+
+    it %(highlights the newline) do
+      expect(refiner.refined_old.to_s).to eq(
+        %(#{RED}-abcde#{reversed('↵')}#{RESET}\n))
+      expect(refiner.refined_new.to_s).to eq(
+        %(#{GREEN}+abcde#{RESET}\n))
+    end
+
+    it %(ends in a newline) do
+      expect(refiner.refined_old.to_s).to end_with("\n")
+      expect(refiner.refined_new.to_s).to end_with("\n")
+    end
+  end
+
+  context %(with large input) do
+    # A Refiner that fails if trying to collect highlights
+    class NonHighlightingRefiner < Refiner
+      def collect_highlights(_diff, _old_highlights, _new_highlights)
+        fail "Shouldn't collect highlights"
+      end
+    end
+
+    old = "0123456789\n"
+    new = '0123456789' * 1500 + "\n"
+
+    it %(doesn't even attempt highlighting) do
+      NonHighlightingRefiner.new(old, new)
+    end
+  end
+end

data/spec/removed-newline-at-eof.diff

@@ -0,0 +1,11 @@
+diff --git a/README.md b/README.md
+index d0aba72..e1fd9c9 100644
+--- a/README.md
++++ b/README.md
+@@ -78,4 +78,4 @@ then we don't want to highlight it.
+ * Refine "ax"->"bx\nc" properly
+ * Strip all color from the input before handling it to enable users to
+   set Git's pager.diff and pager.show variables to 'riff' without also
+-  needing to set color.diff=false.
++  needing to set color.diff=false.
+

data/spec/riff_spec.rb

@@ -0,0 +1,45 @@
+# coding: utf-8
+require 'colors'
+require 'riff'
+
+include Colors
+
+RSpec.describe Riff, '#handle_diff_line' do
+  context 'Removed newline at end of file' do
+    highlighted =
+      Riff.new.do_stream(
+        File.open(File.join(__dir__, 'removed-newline-at-eof.diff')))
+
+    it 'ends the right way' do
+      expect(highlighted.split("\n", -1)[-3..-1]).to eq(
+        "#{RED}-  needing to set color.diff=false.#{reversed('↵')}#{RESET}\n" \
+        "#{GREEN}+  needing to set color.diff=false.#{RESET}\n".split("\n", -1))
+    end
+  end
+
+  context 'Added newline at end of file' do
+    highlighted =
+      Riff.new.do_stream(
+        File.open(File.join(__dir__, 'added-newline-at-eof.diff')))
+
+    it 'ends the right way' do
+      expect(highlighted.split("\n", -1)[-3..-1]).to eq(
+        "#{RED}-  needing to set color.diff=false.#{RESET}\n" \
+        "#{GREEN}+  needing to set color.diff=false.#{reversed('↵')}#{RESET}\n"
+          .split("\n", -1))
+    end
+  end
+
+  context 'No newline at end of file as part of context' do
+    highlighted =
+      Riff.new.do_stream(
+        File.open(File.join(__dir__, 'no-newline-at-eof-context.diff')))
+
+    it 'ends the right way' do
+      expect(highlighted.split("\n", -1)[-3..-1]).to eq(
+        "   needing to set color.diff=false.\n" \
+        "\\n"
+          .split("\n", -1))
+    end
+  end
+end

data/spec/version_spec.rb

@@ -0,0 +1,43 @@
+# coding: utf-8
+require 'version'
+
+include Version
+
+RSpec.describe Version, '#semantify_git_version' do
+  context 'nil version' do
+    it 'returns nil' do
+      expect(semantify_git_version(nil)).to eq(nil)
+    end
+  end
+
+  context 'tagged version' do
+    it 'returns tag.0' do
+      expect(semantify_git_version('1.2')).to eq('1.2.0')
+    end
+  end
+
+  context 'tagged dirty version' do
+    it 'returns the raw version string' do
+      expect(semantify_git_version('1.2-dirty')).to eq('1.2-dirty')
+    end
+  end
+
+  context 'non tagged version' do
+    it 'returns tag.tagged-commits-ago' do
+      expect(semantify_git_version('1.2-5-g695a668')).to eq('1.2.5')
+    end
+  end
+
+  context 'non tagged dirty version' do
+    it 'returns the raw version string' do
+      expect(semantify_git_version('1.2-5-g695a668-dirty')).to(
+        eq('1.2-5-g695a668-dirty'))
+    end
+  end
+end
+
+RSpec.describe Version, '#git_version' do
+  it "doesn't end in a newline" do
+    expect(git_version).to(eq(git_version.chomp))
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: riffdiff
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Johan Walles
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-30 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: johan.walles@gmail.com
+executables:
+- riff
+extensions: []
+extra_rdoc_files: []
+files:
+- ".bundle/config"
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/benchmark
+- bin/bundler
+- bin/htmldiff
+- bin/ldiff
+- bin/riff
+- bin/rspec
+- lib/colors.rb
+- lib/diff_string.rb
+- lib/options.rb
+- lib/pager.rb
+- lib/refiner.rb
+- lib/riff.rb
+- lib/version.rb
+- riffdiff.gemspec
+- spec/added-newline-at-eof.diff
+- spec/colors_spec.rb
+- spec/diff_string_spec.rb
+- spec/no-newline-at-eof-context.diff
+- spec/refiner_spec.rb
+- spec/removed-newline-at-eof.diff
+- spec/riff_spec.rb
+- spec/version_spec.rb
+homepage: http://github.com/walles/riff
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: A diff highlighter showing what parts of lines have changed
+test_files:
+- spec/added-newline-at-eof.diff
+- spec/colors_spec.rb
+- spec/diff_string_spec.rb
+- spec/no-newline-at-eof-context.diff
+- spec/refiner_spec.rb
+- spec/removed-newline-at-eof.diff
+- spec/riff_spec.rb
+- spec/version_spec.rb