sublimetheme 1.0.0

data/path/gems/diff-lcs-1.2.5/lib/diff/lcs/ldiff.rb

@@ -0,0 +1,195 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'optparse'
+require 'ostruct'
+require 'diff/lcs/hunk'
+
+# == ldiff Usage
+#   ldiff [options] oldfile newfile
+#
+# -c::                            Displays a context diff with 3 lines of context.
+# -C [LINES], --context [LINES]:: Displays a context diff with LINES lines of context. Default 3 lines.
+# -u::                            Displays a unified diff with 3 lines of context.
+# -U [LINES], --unified [LINES]:: Displays a unified diff with LINES lines of context. Default 3 lines.
+# -e::                            Creates an 'ed' script to change oldfile to newfile.
+# -f::                            Creates an 'ed' script to change oldfile to newfile in reverse order.
+# -a, --text::                    Treats the files as text and compares them line-by-line, even if they do not seem to be text.
+# --binary::                      Treats the files as binary.
+# -q, --brief::                   Reports only whether or not the files differ, not the details.
+# --help::                        Shows the command-line help.
+# --version::                     Shows the version of Diff::LCS.
+#
+# By default, runs produces an "old-style" diff, with output like UNIX diff.
+#
+# == Copyright
+# Copyright © 2004 Austin Ziegler
+#
+#   Part of Diff::LCS <http://rubyforge.org/projects/ruwiki/>
+#   Austin Ziegler <diff-lcs@halostatue.ca>
+#
+# This program is free software. It may be redistributed and/or modified under
+# the terms of the GPL version 2 (or later), the Perl Artistic licence, or the
+# Ruby licence.
+module Diff::LCS::Ldiff
+  BANNER = <<-COPYRIGHT
+ldiff #{Diff::LCS::VERSION}
+  Copyright 2004-2013 Austin Ziegler
+
+  Part of Diff::LCS.
+  http://rubyforge.org/projects/ruwiki/
+
+  Austin Ziegler <diff-lcs@halostatue.ca>
+
+  This program is free software. It may be redistributed and/or modified under
+  the terms of the GPL version 2 (or later), the Perl Artistic licence, or the
+  MIT licence.
+              COPYRIGHT
+end
+
+class << Diff::LCS::Ldiff
+  attr_reader :format, :lines #:nodoc:
+  attr_reader :file_old, :file_new #:nodoc:
+  attr_reader :data_old, :data_new #:nodoc:
+
+  def run(args, input = $stdin, output = $stdout, error = $stderr) #:nodoc:
+    @binary = nil
+
+    args.options do |o|
+      o.banner = "Usage: #{File.basename($0)} [options] oldfile newfile"
+      o.separator ""
+      o.on('-c', '-C', '--context [LINES]', Numeric, 'Displays a context diff with LINES lines', 'of context. Default 3 lines.') do |ctx|
+        @format = :context
+        @lines  = ctx || 3
+      end
+      o.on('-u', '-U', '--unified [LINES]', Numeric, 'Displays a unified diff with LINES lines', 'of context. Default 3 lines.') do |ctx|
+        @format = :unified
+        @lines  = ctx || 3
+      end
+      o.on('-e', 'Creates an \'ed\' script to change', 'oldfile to newfile.') do |ctx|
+        @format = :ed
+      end
+      o.on('-f', 'Creates an \'ed\' script to change', 'oldfile to newfile in reverse order.') do |ctx|
+        @format = :reverse_ed
+      end
+      o.on('-a', '--text', 'Treat the files as text and compare them', 'line-by-line, even if they do not seem', 'to be text.') do |txt|
+        @binary = false
+      end
+      o.on('--binary', 'Treats the files as binary.') do |bin|
+        @binary = true
+      end
+      o.on('-q', '--brief', 'Report only whether or not the files', 'differ, not the details.') do |ctx|
+        @format = :report
+      end
+      o.on_tail('--help', 'Shows this text.') do
+        error << o
+        return 0
+      end
+      o.on_tail('--version', 'Shows the version of Diff::LCS.') do
+        error << BANNER
+        return 0
+      end
+      o.on_tail ""
+      o.on_tail 'By default, runs produces an "old-style" diff, with output like UNIX diff.'
+      o.parse!
+    end
+
+    unless args.size == 2
+      error << args.options
+      return 127
+    end
+
+    # Defaults are for old-style diff
+    @format ||= :old
+    @lines  ||= 0
+
+    file_old, file_new = *ARGV
+
+    case @format
+    when :context
+      char_old = '*' * 3
+      char_new = '-' * 3
+    when :unified
+      char_old = '-' * 3
+      char_new = '+' * 3
+    end
+
+    # After we've read up to a certain point in each file, the number of
+    # items we've read from each file will differ by FLD (could be 0).
+    file_length_difference = 0
+
+    if @binary.nil? or @binary
+      data_old = IO::read(file_old)
+      data_new = IO::read(file_new)
+
+      # Test binary status
+      if @binary.nil?
+        old_txt = data_old[0...4096].scan(/\0/).empty?
+        new_txt = data_new[0...4096].scan(/\0/).empty?
+        @binary = (not old_txt) or (not new_txt)
+        old_txt = new_txt = nil
+      end
+
+      unless @binary
+        data_old = data_old.split($/).map { |e| e.chomp }
+        data_new = data_new.split($/).map { |e| e.chomp }
+      end
+    else
+      data_old = IO::readlines(file_old).map { |e| e.chomp }
+      data_new = IO::readlines(file_new).map { |e| e.chomp }
+    end
+
+    # diff yields lots of pieces, each of which is basically a Block object
+    if @binary
+      diffs = (data_old == data_new)
+    else
+      diffs = Diff::LCS.diff(data_old, data_new)
+      diffs = nil if diffs.empty?
+    end
+
+    return 0 unless diffs
+
+    if @format == :report
+      output << "Files #{file_old} and #{file_new} differ\n"
+      return 1
+    end
+
+    if (@format == :unified) or (@format == :context)
+      ft = File.stat(file_old).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S.%N %z')
+      puts "#{char_old} #{file_old}\t#{ft}"
+      ft = File.stat(file_new).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S.%N %z')
+      puts "#{char_new} #{file_new}\t#{ft}"
+    end
+
+    # Loop over hunks. If a hunk overlaps with the last hunk, join them.
+    # Otherwise, print out the old one.
+    oldhunk = hunk = nil
+
+    if @format == :ed
+      real_output = output
+      output = []
+    end
+
+    diffs.each do |piece|
+      begin
+        hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, @lines,
+                                   file_length_difference)
+        file_length_difference = hunk.file_length_difference
+
+        next unless oldhunk
+        next if (@lines > 0) and hunk.merge(oldhunk)
+
+        output << oldhunk.diff(@format) << "\n"
+      ensure
+        oldhunk = hunk
+      end
+    end
+
+    output << oldhunk.diff(@format) << "\n"
+
+    if @format == :ed
+      output.reverse_each { |e| real_output << e.diff(:ed_finish) }
+    end
+
+    return 1
+  end
+end

data/path/gems/diff-lcs-1.2.5/lib/diff/lcs/string.rb

@@ -0,0 +1,5 @@
+# -*- ruby encoding: utf-8 -*-
+
+class String
+  include Diff::LCS
+end

data/path/gems/diff-lcs-1.2.5/spec/change_spec.rb

@@ -0,0 +1,65 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe Diff::LCS::Change do
+  describe "an add" do
+    subject { described_class.new('+', 0, 'element') }
+    it { should_not be_deleting   }
+    it { should     be_adding     }
+    it { should_not be_unchanged  }
+    it { should_not be_changed    }
+    it { should_not be_finished_a }
+    it { should_not be_finished_b }
+  end
+
+  describe "a delete" do
+    subject { described_class.new('-', 0, 'element') }
+    it { should     be_deleting   }
+    it { should_not be_adding     }
+    it { should_not be_unchanged  }
+    it { should_not be_changed    }
+    it { should_not be_finished_a }
+    it { should_not be_finished_b }
+  end
+
+  describe "an unchanged" do
+    subject { described_class.new('=', 0, 'element') }
+    it { should_not be_deleting   }
+    it { should_not be_adding     }
+    it { should     be_unchanged  }
+    it { should_not be_changed    }
+    it { should_not be_finished_a }
+    it { should_not be_finished_b }
+  end
+
+  describe "a changed" do
+    subject { described_class.new('!', 0, 'element') }
+    it { should_not be_deleting   }
+    it { should_not be_adding     }
+    it { should_not be_unchanged  }
+    it { should     be_changed    }
+    it { should_not be_finished_a }
+    it { should_not be_finished_b }
+  end
+
+  describe "a finished_a" do
+    subject { described_class.new('>', 0, 'element') }
+    it { should_not be_deleting   }
+    it { should_not be_adding     }
+    it { should_not be_unchanged  }
+    it { should_not be_changed    }
+    it { should     be_finished_a }
+    it { should_not be_finished_b }
+  end
+
+  describe "a finished_b" do
+    subject { described_class.new('<', 0, 'element') }
+    it { should_not be_deleting   }
+    it { should_not be_adding     }
+    it { should_not be_unchanged  }
+    it { should_not be_changed    }
+    it { should_not be_finished_a }
+    it { should     be_finished_b }
+  end
+end

data/path/gems/diff-lcs-1.2.5/spec/diff_spec.rb

@@ -0,0 +1,47 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe "Diff::LCS.diff" do
+  include Diff::LCS::SpecHelper::Matchers
+
+  it "should correctly diff seq1 to seq2" do
+    diff_s1_s2 = Diff::LCS.diff(seq1, seq2)
+    change_diff(correct_forward_diff).should == diff_s1_s2
+  end
+
+  it "should correctly diff seq2 to seq1" do
+    diff_s2_s1 = Diff::LCS.diff(seq2, seq1)
+    change_diff(correct_backward_diff).should == diff_s2_s1
+  end
+
+  it "should correctly diff against an empty sequence" do
+    diff = Diff::LCS.diff(word_sequence, [])
+    correct_diff = [
+      [ [ '-', 0, 'abcd'           ],
+        [ '-', 1, 'efgh'           ],
+        [ '-', 2, 'ijkl'           ],
+        [ '-', 3, 'mnopqrstuvwxyz' ] ]
+    ]
+
+    change_diff(correct_diff).should == diff
+
+    diff = Diff::LCS.diff([], word_sequence)
+    correct_diff.each { |hunk| hunk.each { |change| change[0] = '+' } }
+    change_diff(correct_diff).should == diff
+  end
+
+  it "should correctly diff 'xx' and 'xaxb'" do
+    left = 'xx'
+    right = 'xaxb'
+    Diff::LCS.patch(left, Diff::LCS.diff(left, right)).should == right
+  end
+
+  it "should return an empty diff with (hello, hello)" do
+    Diff::LCS.diff(hello, hello).should == []
+  end
+
+  it "should return an empty diff with (hello_ary, hello_ary)" do
+    Diff::LCS.diff(hello_ary, hello_ary).should == []
+  end
+end

data/path/gems/diff-lcs-1.2.5/spec/hunk_spec.rb

@@ -0,0 +1,72 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'spec_helper'
+
+def h(v)
+  v.to_s.bytes.to_a.map { |e| "%02x" % e }.join
+end
+
+describe "Diff::LCS::Hunk" do
+  if String.method_defined?(:encoding)
+
+    let(:old_data) { ["Tu avec carté {count} itém has".encode('UTF-16LE')] }
+    let(:new_data) { ["Tu avec carte {count} item has".encode('UTF-16LE')] }
+    let(:pieces)   { Diff::LCS.diff old_data, new_data }
+    let(:hunk)     { Diff::LCS::Hunk.new(old_data, new_data, pieces[0], 3, 0) }
+
+    it 'should be able to produce a unified diff from the two pieces' do
+      expected = (<<-EOD.gsub(/^\s+/,'').encode('UTF-16LE').chomp)
+        @@ -1,2 +1,2 @@
+        -Tu avec carté {count} itém has
+        +Tu avec carte {count} item has
+      EOD
+      expect(hunk.diff(:unified).to_s == expected).to eql true
+    end
+
+    it 'should be able to produce a context diff from the two pieces' do
+      expected = (<<-EOD.gsub(/^\s+/,'').encode('UTF-16LE').chomp)
+        ***************
+        *** 1,2 ****
+        !Tu avec carté {count} itém has
+        --- 1,2 ----
+        !Tu avec carte {count} item has
+      EOD
+
+      expect(hunk.diff(:context).to_s == expected).to eql true
+    end
+
+    it 'should be able to produce an old diff from the two pieces' do
+      expected = (<<-EOD.gsub(/^ +/,'').encode('UTF-16LE').chomp)
+        1,2c1,2
+        < Tu avec carté {count} itém has
+        ---
+        > Tu avec carte {count} item has
+
+      EOD
+      expect(hunk.diff(:old).to_s == expected).to eql true
+    end
+
+    it 'should be able to produce a reverse ed diff from the two pieces' do
+      expected = (<<-EOD.gsub(/^ +/,'').encode('UTF-16LE').chomp)
+        c1,2
+        Tu avec carte {count} item has
+        .
+
+      EOD
+      expect(hunk.diff(:reverse_ed).to_s == expected).to eql true
+    end
+
+    context 'with empty first data set' do
+      let(:old_data) { [] }
+
+      it 'should be able to produce a unified diff' do
+        expected = (<<-EOD.gsub(/^\s+/,'').encode('UTF-16LE').chomp)
+          @@ -1 +1,2 @@
+          +Tu avec carte {count} item has
+        EOD
+        expect(hunk.diff(:unified).to_s == expected).to eql true
+      end
+    end
+
+  end
+end

data/path/gems/diff-lcs-1.2.5/spec/issues_spec.rb

@@ -0,0 +1,24 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe "Diff::LCS Issues" do
+  include Diff::LCS::SpecHelper::Matchers
+
+  it "should not fail to provide a simple patchset (issue 1)" do
+    s1, s2 = *%W(aX bXaX)
+    correct_forward_diff = [
+      [ [ '+', 0, 'b' ],
+        [ '+', 1, 'X' ] ],
+    ]
+
+    diff_s1_s2 = Diff::LCS.diff(s1, s2)
+    change_diff(correct_forward_diff).should == diff_s1_s2
+    expect do
+      Diff::LCS.patch(s1, diff_s1_s2).should == s2
+    end.to_not raise_error(RuntimeError, /provided patchset/)
+    expect do
+      Diff::LCS.patch(s2, diff_s1_s2).should == s1
+    end.to_not raise_error(RuntimeError, /provided patchset/)
+  end
+end

data/path/gems/diff-lcs-1.2.5/spec/lcs_spec.rb

@@ -0,0 +1,54 @@
+# -*- ruby encoding: utf-8 -*-
+
+require 'spec_helper'
+
+describe "Diff::LCS::Internals.lcs" do
+  include Diff::LCS::SpecHelper::Matchers
+
+  it "should return a meaningful LCS array with (seq1, seq2)" do
+    res = Diff::LCS::Internals.lcs(seq1, seq2)
+    # The result of the LCS (less the +nil+ values) must be as long as the
+    # correct result.
+    res.compact.size.should == correct_lcs.size
+    res.should correctly_map_sequence(seq1).to_other_sequence(seq2)
+
+    # Compact these transformations and they should be the correct LCS.
+    x_seq1 = (0...res.size).map { |ix| res[ix] ? seq1[ix] : nil }.compact
+    x_seq2 = (0...res.size).map { |ix| res[ix] ? seq2[res[ix]] : nil }.compact
+
+    x_seq1.should == correct_lcs
+    x_seq2.should == correct_lcs
+  end
+
+  it "should return all indexes with (hello, hello)" do
+    Diff::LCS::Internals.lcs(hello, hello).should == (0...hello.size).to_a
+  end
+
+  it "should return all indexes with (hello_ary, hello_ary)" do
+    Diff::LCS::Internals.lcs(hello_ary, hello_ary).should == (0...hello_ary.size).to_a
+  end
+end
+
+describe "Diff::LCS.LCS" do
+  include Diff::LCS::SpecHelper::Matchers
+
+  it "should return the correct compacted values from Diff::LCS.LCS" do
+    res = Diff::LCS.LCS(seq1, seq2)
+    res.should == correct_lcs
+    res.compact.should == res
+  end
+
+  it "should be transitive" do
+    res = Diff::LCS.LCS(seq2, seq1)
+    res.should == correct_lcs
+    res.compact.should == res
+  end
+
+  it "should return %W(h e l l o) with (hello, hello)" do
+    Diff::LCS.LCS(hello, hello).should == hello.split(//)
+  end
+
+  it "should return hello_ary with (hello_ary, hello_ary)" do
+    Diff::LCS.LCS(hello_ary, hello_ary).should == hello_ary
+  end
+end