unified 1.0.0

data/spec/parser_spec.rb

@@ -0,0 +1,344 @@
+require "unified/parser"
+require "spec_helper"
+
+# Hashes used to validate captures
+header_without_revision = {
+  :filename => {:string => "Filename"},
+}
+header_with_revision = {
+  :revision => {:string => "revision"}
+}.merge(header_without_revision)
+
+original_file_header = {
+  :original => header_with_revision
+}
+
+modified_file_header = {
+  :modified => header_with_revision
+}
+
+describe "Unified::Parser" do
+  let(:parser) { Unified::Parser.new }
+  subject { parser }
+
+  it { should parse_all valid_diffs }
+  it { should_not parse_any invalid_diffs }
+
+  describe "#minus" do
+    subject { parser.minus }
+
+    it { should parse "-" }
+    it { should_not parse_empty_string }
+    it { should_not parse "+" }
+  end
+
+  describe "#plus" do
+    subject { parser.plus }
+
+    it { should parse "+" }
+    it { should_not parse_empty_string }
+    it { should_not parse "-" }
+  end
+
+  describe "#digit" do
+    subject { parser.digit }
+
+    it { should parse "9" }
+    it { should parse "0" }
+
+    it { should_not parse "a" }
+    it { should_not parse_empty_string }
+    it { should_not parse "2141" }
+  end
+
+  describe "#digits" do
+    subject { parser.digits }
+
+    it { should parse "123" }
+    it { should parse "1" }
+    it { should_not parse "a" }
+    it { should_not parse_empty_string }
+
+  end
+
+  describe "#space" do
+    subject { parser.space }
+
+    it { should parse " " }
+    it { should parse "\s" }
+    it { should_not parse_empty_string }
+    it { should_not parse "some content"}
+    it { should_not parse "   " }
+    it { should_not parse "\t" }
+  end
+
+  describe "#space?" do
+    subject { parser.space? }
+
+    it { should parse " " }
+    it { should parse_empty_string }
+    it { should_not parse "a" }
+    it { should_not parse "  " }
+  end
+
+  describe "#tab" do
+    subject { parser.tab }
+
+    it { should parse "\t" }
+    it { should_not parse " " }
+  end
+
+  describe "#newline" do
+    subject { parser.newline }
+
+    it { should parse "\n" }
+    it { should parse "\r\n" }
+
+    it { should_not parse_empty_string }
+    it { should_not parse "\n\n" }
+  end
+
+  describe "#rest_of_line" do
+    subject { parser.rest_of_line }
+
+    it { should parse "a long string of content" }
+    it { should parse "strings with\t(special_characters)" }
+    it { should parse_empty_string }
+    it { should_not parse "strings ending with a newline\n" }
+  end
+
+  describe "#text_until_tab" do
+    subject { parser.text_until_tab }
+
+    it { should parse "a string with names in" }
+    it { should_not parse "a string with a tab\t" }
+
+    it "should capture filename as {:string => 'filename'}" do
+      expect(subject.parse("String until tab")).to eq :string => "String until tab"
+    end
+  end
+
+  describe "#header_information" do
+    subject { parser.header_information }
+
+    it { should parse "This/is/a/filename" }
+    it { should parse "Filename" }
+    it { should parse "Filename\trevision" }
+
+    it "should capture header as {:filename => 'filename', :revision => 'revision'}" do
+
+
+      expect(subject.parse("Filename")).to eq header_without_revision
+      expect(subject.parse("Filename\trevision")).to eq header_with_revision
+    end
+  end
+
+  describe "#original_file_marker" do
+    subject { parser.original_file_marker }
+
+    it { should parse "--- " }
+    it { should_not parse_empty_string }
+    it { should_not parse "-- " }
+    it { should_not parse "---" }
+    it { should_not parse "---- " }
+  end
+
+  describe "#modified_file_marker" do
+    subject { parser.modified_file_marker }
+
+    it { should parse "+++ " }
+    it { should_not parse_empty_string }
+    it { should_not parse "++ " }
+    it { should_not parse "+++" }
+    it { should_not parse "++++ " }
+  end
+
+  describe "#original_file_header" do
+    subject { parser.original_file_header }
+
+    it { should parse "--- Filename\t2002-02-21 23:30:39.942229878 -0800\n" }
+    it { should parse "--- Filename\t2002-02-21 23:30:39.942229878 -0800\r\n" }
+    it { should parse "--- Filename\t(working copy)\n" }
+    it { should parse "--- Filename\t(working copy)\r\n" }
+    it { should parse "--- Filename\n" }
+
+    it { should_not parse "--- Filename\t(working copy)"}
+
+    it "should capture all header information" do
+      expect(subject.parse("--- Filename\trevision\n")).to eq original_file_header
+    end
+  end
+
+  describe "#modified_file_header" do
+    subject { parser.modified_file_header }
+
+    it { should parse "+++ Filename\t2002-02-21 23:30:39.942229878 -0800\n" }
+    it { should parse "+++ Filename\t2002-02-21 23:30:39.942229878 -0800\r\n" }
+    it { should parse "+++ Filename\t(working copy)\n" }
+    it { should parse "+++ Filename\t(working copy)\r\n" }
+    it { should parse "+++ Filename\n"}
+
+    it { should_not parse "+++ Filename\t(working copy)"}
+
+    it "should capture all header information" do
+      expect(subject.parse("+++ Filename\trevision\n")).to eq modified_file_header
+    end
+  end
+
+  describe "#chunk_marker" do
+    subject { parser.chunk_marker }
+
+    it { should parse "@@" }
+    it { should_not parse "@" }
+    it { should_not parse " @@" }
+    it { should_not parse "@@ " }
+  end
+
+  describe "#line_numbers" do
+    subject { parser.line_numbers }
+
+    it { should parse "1" }
+    it { should parse "1,5" }
+    it { should parse "101,101" }
+
+    it "captures line numbers as {:line_number => 'digits'}" do
+      expect(subject.parse("1,5")).to eq :line_number => "1"
+      expect(subject.parse("101,101")).to eq :line_number => "101"
+      expect(subject.parse("1")).to eq :line_number => "1"
+    end
+  end
+
+  describe "#chunk_header" do
+    subject { parser.chunk_header }
+
+    it { should parse "@@ -1 +1 @@\n" }
+    it { should parse "@@ -1,5 +1,5 @@\n" }
+    it { should parse "@@ -101,15 +102,14 @@ Some optional heading\n" }
+
+    it "captures all required information" do
+      expect(subject.parse("@@ -1 +1 @@\n")).to eq({
+        :original => {
+          :line_number => "1"
+        },
+        :modified => {
+          :line_number => "1"
+        }
+      })
+
+      expect(subject.parse("@@ -101,15 +102,14 @@ Some optional heading\n")).to eq({
+        :original => {
+          :line_number => "101"
+        },
+        :modified => {
+          :line_number => "102"
+        },
+        :section_heading => { string: "Some optional heading" }
+      })
+    end
+  end
+
+  describe "#added_line" do
+    subject { parser.added_line }
+
+    it { should parse "+This is an additional line" }
+    it { should_not parse " +This is not a valid additional line" }
+    it { should parse "+++Even though this looks like a header, it should parse" }
+  end
+
+  describe "#deleted_line" do
+    subject { parser.deleted_line }
+
+    it { should parse "-This is a deleted line" }
+    it { should_not parse " -This is not a valid deleted line" }
+    it { should parse "---Even though this looks like a header, it should parse" }
+  end
+
+  describe "#unchanged_line" do
+    subject { parser.unchanged_line }
+
+    it { should parse " this line is unchanged" }
+    it { should_not parse "This has no leading space" }
+    it { should_not parse_empty_string }
+  end
+
+  describe "#no_newline_notice" do
+    subject { parser.no_newline_notice }
+
+    it { should parse "\" }
+  end
+
+  describe "#line" do
+    subject { parser.line }
+
+    it { should parse "+This is an additional line" }
+    it { should parse "-This is a deleted line" }
+    it { should parse " this line is unchanged" }
+    it { should parse "\" }
+
+    it "captures all line content as {:string => 'content'}" do
+      expect(subject.parse("+This is an additional line")).to eq :string => "+This is an additional line"
+      expect(subject.parse("-This is a deleted line")).to eq :string => "-This is a deleted line"
+      expect(subject.parse(" this line is unchanged")).to eq :string => " this line is unchanged"
+      expect(subject.parse("\")).to eq :string => "\"
+    end
+  end
+
+  describe "#chunk" do
+    subject { parser.chunk }
+    valid_chunk = "@@ -1 +1 @@\n+addition\n-deletion\n no change"
+    a_chunk_with_no_lines = "@@ -1 +1 @@\n"
+    a_chunk_with_no_header = "+addition\n-deletion\n no change"
+
+    it { should parse valid_chunk }
+    it { should_not parse a_chunk_with_no_lines }
+    it { should_not parse a_chunk_with_no_header }
+
+    context "captures" do
+      let(:capture) { subject.parse valid_chunk }
+      it "captures as chunk" do
+        capture.should include :chunk
+      end
+
+      it "captures lines" do
+        capture[:chunk].should include :lines
+        capture[:chunk][:lines].size.should == 3
+        capture[:chunk][:lines].each do |line|
+          line.should include :line
+        end
+      end
+    end
+
+  end
+
+  describe "#unified_diff_header" do
+    subject { parser.unified_diff_header }
+
+    it { should parse "--- Filename\n+++ Filename\n" }
+    it { should_not parse "--- Missing header\n" }
+    it { should_not parse "\n+++ Missing header\n"}
+  end
+
+  describe "#unified_diff" do
+    subject { parser.unified_diff }
+
+    it { should parse valid_diffs.first }
+    it { should_not parse invalid_diffs.first }
+
+    context "capturing all necessary information" do
+      let(:result) { subject.parse valid_diffs.first }
+
+      it "captures as a diff hash" do
+        result.should include(:diff)
+      end
+
+      it "captures a diff header" do
+        result[:diff].should include(:diff_header)
+      end
+
+      it "captures chunks" do
+        result[:diff].should include(:chunks)
+        result[:diff][:chunks].size.should == 1
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.order = 'random'
+end
+
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
+
+def load_diffs_from(dir)
+  Dir.glob(File.dirname(__FILE__) + '/' + dir + '/*.diff').map {|f| File.read(f) }
+end
+
+def valid_diffs
+  load_diffs_from("examples/valid")
+end
+
+def invalid_diffs
+  load_diffs_from("examples/invalid")
+end

data/spec/support/matchers/parse_matchers.rb

@@ -0,0 +1,53 @@
+RSpec::Matchers.define :parse do |string_to_parse|
+  match do |parser|
+    begin
+      parser.parse(string_to_parse)
+    rescue Parslet::ParseFailed => e
+      # @exception = e
+      @exception = e.cause.ascii_tree
+      false
+    end
+  end
+
+  failure_message_for_should do |parser|
+    @exception + "\n\n" + string_to_parse
+  end
+end
+
+RSpec::Matchers.define :parse_empty_string do
+  match do |parser|
+    begin
+      parser.parse("")
+    rescue Parslet::ParseFailed => e
+      @exception = e.cause.ascii_tree
+      false
+    end
+  end
+end
+
+RSpec::Matchers.define :parse_all do |diffs|
+  match do |parser|
+    begin
+      diffs.each do |diff|
+        parser.parse(diff)
+      end
+    rescue Parslet::ParseFailed => e
+      @exception = e.cause.ascii_tree
+      false
+    end
+  end
+end
+
+# TODO Can you have aliases for RSpec matchers?
+RSpec::Matchers.define :parse_any do |diffs|
+  match do |parser|
+    begin
+      diffs.each do |diff|
+        parser.parse(diff)
+      end
+    rescue Parslet::ParseFailed => e
+      @exception = e.cause.ascii_tree
+      false
+    end
+  end
+end

data/spec/transformer_spec.rb

@@ -0,0 +1,82 @@
+require "unified/transformer"
+require "spec_helper"
+
+
+
+describe "Unified::Transformer" do
+  def lines
+    [" Line 1", " Line 2", " Line 3", "-Line 5", "-Line 6", "-Line 7", "+Line 4", "+Line 5"]
+  end
+
+  def build_chunk_hash(original_line_number = 1, modified_line_number = 1, header = nil)
+    {:chunk=>{:original=>original_line_number, :modified=>modified_line_number, :section_heading=>header, :lines=>lines}}
+  end
+  let(:transformer) { Unified::Transformer.new }
+
+  context "simple values" do
+    it "transforms a string value" do
+      expect(transformer.apply({:string => "a string"})).to eq("a string")
+    end
+  end
+
+  context "Lines" do
+    it "transforms a line into a Unified::Line object" do
+      expect(transformer.apply({:line => {:string => "+A line"}})).to eq(Unified::Line.new("+A line"))
+    end
+  end
+
+  context "Chunks" do
+    let(:chunk) { build_chunk_hash }
+    it "transforms a chunk into a Unified::Chunk object" do
+      expect(transformer.apply(chunk)).to eq(Unified::Chunk.new(original: 1, modified: 1, section_heading: "A section heading", lines: lines))
+    end
+  end
+
+  describe "Diff header" do
+    let(:header) { {:original=>{:filename=>"Original", :revision=>"OrigRev"}, :modified=>{:filename=>"Modified", :revision=>"ModRev"}} }
+    it "transforms a diff header into filenames and revisions" do
+      expect(transformer.apply(header)).to eq({
+        original_filename: "Original",
+        modified_filename: "Modified",
+        original_revision: "OrigRev",
+        modified_revision: "ModRev"
+      })
+    end
+  end
+
+  # context "Diffs" do
+  #   let(:chunks) { [build_chunk_hash, build_chunk_hash(101, 101)] }
+  #   let(:diff_hash) do
+  #     {
+  #       :diff => {
+  #         :diff_header => {
+  #           :original => {
+  #             :filename=>"Original",
+  #             :revision=>"OriginalRevision"
+  #           },
+  #           :modified => {
+  #             :filename=>"Modified",
+  #             :revision=>"ModifiedRevision"
+  #           }
+  #         },
+  #         :chunks => chunks
+  #       }
+  #     }
+  #   end
+  #   let(:diff) {
+  #     Unified::Diff.new(
+  #       original_filename: "Original",
+  #       original_revision: "OriginalRevision",
+  #       modified_filename: "Modified",
+  #       modified_revision: "ModifiedRevision",
+  #       chunks: [
+  #         Unified::Chunk.new(original: 1, modified: 1, lines: lines),
+  #         Unified::Chunk.new(original: 101, modified: 101, lines: lines)
+  #       ]
+  #     )
+  #   }
+  #   it "transforms a diff into a Unified::Diff object" do
+  #     expect(transformer.apply(diff_hash)).to eq(diff)
+  #   end
+  # end
+end