unified 1.0.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in unified.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Matthew Williams
+
+MIT License
+
+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,33 @@
+# Unified
+
+Unified is a gem for parsing unified diff files into usable diff files.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'unified'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install unified
+
+## Usage
+
+To parse a diff file:
+
+    Unified::Diff.parse!(diff_content)
+
+Where diff_content is a valid unified diff string.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/unified.rb

@@ -0,0 +1,8 @@
+require "unified/version"
+
+require "unified/parser"
+require "unified/transformer"
+
+require "unified/diff"
+require "unified/chunk"
+require "unified/line"

data/lib/unified/chunk.rb

@@ -0,0 +1,88 @@
+module Unified
+  class Chunk
+
+    attr_reader :original_line_number
+    attr_reader :modified_line_number
+    attr_reader :lines
+    attr_reader :section_header
+
+    def initialize(attrs = {})
+      @original_line_number = attrs[:original]
+      @modified_line_number = attrs[:modified]
+      @section_header = attrs[:section_header]
+      @lines = attrs[:lines].map {|s| Unified::Line.new(s) }
+    end
+
+    def total_number_of_lines
+      @number_of_lines ||= @lines.size
+    end
+
+    def number_of_deleted_lines
+      @number_of_added_lines ||= number_of_lines_by_type(:deletion?)
+    end
+
+    def number_of_added_lines
+      @number_of_deleted_lines ||= number_of_lines_by_type(:addition?)
+    end
+
+    def number_of_unchanged_lines
+      @number_of_unchanged_lines ||= number_of_lines_by_type(:unchanged?)
+    end
+
+    def number_of_original_lines
+      @number_of_original_lines ||= number_of_unchanged_lines + number_of_deleted_lines
+    end
+
+    def number_of_modified_lines
+      @number_of_modified_lines ||= number_of_unchanged_lines + number_of_added_lines
+    end
+
+    def header
+      parts = "@@"
+      parts << " -#{@original_line_number}"
+      parts << ",#{number_of_original_lines}" unless number_of_original_lines == 1
+      parts << " +#{@modified_line_number}"
+      parts << ",#{number_of_modified_lines}" unless number_of_modified_lines == 1
+      parts << " @@"
+      parts << " #{@section_header}" unless @section_header.nil?
+      parts
+    end
+
+    def to_s
+      header + "\n" + @lines.join("\n")
+    end
+
+    # Iterator for lines passing |line, original_line_number, modified_line_number| as block arguments
+    def each_line
+      original_line_number = @original_line_number
+      modified_line_number = @modified_line_number
+
+      @lines.each do |line|
+        if line.addition?
+          yield line, nil, modified_line_number
+          modified_line_number += 1
+        elsif line.deletion?
+          yield line, original_line_number, nil
+          original_line_number += 1
+        else
+          yield line, original_line_number, modified_line_number
+          original_line_number += 1
+          modified_line_number += 1
+        end
+      end
+    end
+
+    def ==(another)
+     @modified_line_number == another.modified_line_number and
+     @original_line_number == another.original_line_number and
+     @section_header == another.section_header and
+     @lines = another.lines
+    end
+
+  private
+
+    def number_of_lines_by_type(type)
+      @lines.inject(0) {|total, line| line.send(type) ? total + 1 : total}
+    end
+  end
+end

data/lib/unified/diff.rb

@@ -0,0 +1,74 @@
+module Unified
+  class ParseError < StandardError; end
+  class Diff
+
+    attr_reader :original_filename
+    attr_reader :modified_filename
+    attr_reader :original_revision
+    attr_reader :modified_revision
+    attr_reader :chunks
+
+    def initialize(attrs={})
+      @original_filename = attrs[:original_filename]
+      @modified_filename = attrs[:modified_filename]
+      @original_revision = attrs[:original_revision]
+      @modified_revision = attrs[:modified_revision]
+      @chunks = attrs[:chunks]
+    end
+
+    def self.parse!(content)
+      begin
+        Unified::Transformer.new.apply(Unified::Parser.new.parse(content))
+      rescue StandardError => e
+        raise Unified::ParseError, e.message
+      end
+    end
+
+    def total_number_of_lines
+      @total_number_of_lines ||= number_of_added_lines + number_of_deleted_lines + number_of_unchanged_lines
+    end
+
+    def number_of_added_lines
+      @number_of_added_lines ||= @chunks.inject(0) {|total, chunk| total + chunk.number_of_added_lines}
+    end
+
+    def number_of_deleted_lines
+      @number_of_deleted_lines ||= @chunks.inject(0) {|total, chunk| total + chunk.number_of_deleted_lines}
+    end
+
+    def number_of_unchanged_lines
+      @number_of_unchanged_lines ||= @chunks.inject(0) {|total, chunk| total + chunk.number_of_unchanged_lines}
+    end
+
+    def number_of_modified_lines
+      @number_of_modified_lines ||= number_of_deleted_lines + number_of_added_lines
+    end
+
+    def proportion_of_deleted_lines
+      @proportion_of_deleted_lines ||= ((100.0 * number_of_deleted_lines / number_of_modified_lines)).round
+    end
+
+    def proportion_of_added_lines
+      @proportion_of_added_lines ||= 100 - proportion_of_deleted_lines
+    end
+
+    def header
+      "--- #{@original_filename}\t#{@original_revision}\n+++ #{modified_filename}\t#{@modified_revision}"
+    end
+
+    def to_s
+      str = [header]
+      @chunks.each do |chunk|
+        str << chunk.to_s
+      end
+      str.join("\n")
+    end
+
+    def each_chunk
+      @chunks.each do |chunk|
+        yield chunk
+      end
+    end
+
+  end
+end

data/lib/unified/line.rb

@@ -0,0 +1,21 @@
+module Unified
+  class Line < String
+
+    def addition?
+      @addition ||= first_character == "+"
+    end
+
+    def deletion?
+      @deletion ||= first_character == "-"
+    end
+
+    def unchanged?
+      @unchanged ||= first_character == " "
+    end
+
+  private
+    def first_character
+      @first_character ||= self[0]
+    end
+  end
+end

data/lib/unified/parser.rb

@@ -0,0 +1,53 @@
+require 'parslet'
+
+module Unified
+  class Parser < Parslet::Parser
+    rule(:minus) { str('-') }
+    rule(:plus) { str('+') }
+    rule(:space) { str(' ') }
+    rule(:space?) { str(' ').maybe }
+    rule(:digit) { match['0-9'] }
+    rule(:digits) { digit.repeat(1) }
+    rule(:tab) { match['\\t'] }
+    rule(:newline) { match['\\r'].maybe >> match['\\n'] }
+    rule(:text_until_tab) { (tab.absent? >> newline.absent? >> any).repeat.as(:string) }
+    rule(:rest_of_line) { (newline.absent? >> any).repeat }
+
+    rule(:original_file_marker) { str('--- ') }
+    rule(:modified_file_marker) { str('+++ ') }
+    rule(:revision) { rest_of_line.as(:string) }
+    rule(:header_information) { text_until_tab.as(:filename) >> (tab >> revision.as(:revision)).maybe }
+
+    rule(:original_file_header) { original_file_marker >> header_information.as(:original) >> newline }
+    rule(:modified_file_header) { modified_file_marker >> header_information.as(:modified) >> newline }
+
+    rule(:chunk_marker) { str('@@') }
+    rule(:line_numbers) do
+      digits.as(:line_number) >> (str(',') >> digits).maybe
+    end
+    rule(:chunk_header) do
+      chunk_marker >> space >>
+      minus >> line_numbers.as(:original) >> space >>
+      plus  >> line_numbers.as(:modified) >> space >>
+      chunk_marker >> (space >> rest_of_line.as(:string).as(:section_heading)).maybe >>
+      newline
+    end
+
+    rule(:added_line) { plus >> rest_of_line }
+    rule(:deleted_line) { minus >> rest_of_line }
+    rule(:unchanged_line) { space >> rest_of_line }
+    rule(:no_newline_notice) { str('\') }
+    rule(:line) { (added_line | deleted_line | unchanged_line | no_newline_notice).as(:string) >> newline.maybe }
+
+    rule(:chunk) do
+      (chunk_header >> line.as(:line).repeat(1).as(:lines)).as(:chunk)
+    end
+
+    rule(:unified_diff_header) { original_file_header >> modified_file_header }
+    rule(:unified_diff) do
+      (unified_diff_header.as(:diff_header) >>
+      chunk.repeat(1).as(:chunks)).as(:diff)
+    end
+    root(:unified_diff)
+  end
+end

data/lib/unified/transformer.rb

@@ -0,0 +1,25 @@
+require "unified/chunk"
+require "unified/diff"
+require "unified/line"
+
+module Unified
+  class Transformer < Parslet::Transform
+    rule(:string => simple(:s)) { String(s) }
+    rule(:line_number => simple(:n)) { Integer(n) }
+    rule(:line => subtree(:line)) { Line.new line }
+    rule(:chunk => subtree(:chunk)) { Chunk.new chunk }
+    rule(:original => subtree(:original), :modified => subtree(:modified)) do
+      {
+        :original_filename => original[:filename],
+        :modified_filename => modified[:filename],
+        :original_revision => original[:revision],
+        :modified_revision => modified[:revision]
+      }
+    end
+    rule(:diff_header => subtree(:header), :chunks => subtree(:chunks)) do
+      header[:chunks] = chunks
+      header
+    end
+    rule(:diff => subtree(:d)) { Diff.new d }
+  end
+end

data/lib/unified/version.rb

@@ -0,0 +1,3 @@
+module Unified
+  VERSION = "1.0.0"
+end

data/spec/chunk_spec.rb

@@ -0,0 +1,134 @@
+require "unified/chunk"
+
+describe "Unified::Chunk" do
+  let(:lines) { [" Line 1", "+Line 2", "-Line 3", "+Line4", "-Line5", " Line6"] }
+  let(:chunk_without_section_header) { Unified::Chunk.new original: 1, modified: 2, lines: lines }
+  let(:chunk) { Unified::Chunk.new original: 1, modified: 2, lines: lines, section_header: "A section header" }
+  describe "#original_line_number" do
+    it "returns the correct number" do
+      chunk.original_line_number.should == 1
+    end
+  end
+  describe "#modified_line_number" do
+    it "returns the correct number" do
+      chunk.modified_line_number.should == 2
+    end
+  end
+
+  describe "#total_number_of_lines" do
+    it "returns the number of lines" do
+      chunk.total_number_of_lines.should == lines.length
+    end
+  end
+
+  describe "#number_of_deleted_lines" do
+    it "returns the number of lines beginning with '-'" do
+      chunk.number_of_deleted_lines.should == 2
+    end
+  end
+
+  describe "#number_of_added_lines" do
+    it "returns the number of lines beginning with '+'" do
+      chunk.number_of_added_lines.should == 2
+    end
+  end
+
+  describe "#number_of_unchanged_lines" do
+    it "returns the number of lines beginning with ' '" do
+      chunk.number_of_unchanged_lines.should == 2
+    end
+  end
+
+  describe "#number_of_original_lines" do
+    it "returns the number of lines within the original chunk" do
+      chunk.number_of_original_lines.should == 4
+    end
+  end
+
+  describe "#number_of_modified_lines" do
+    it "returns the number of lines within the modified chunk" do
+      chunk.number_of_modified_lines.should == 4
+    end
+  end
+
+  describe "#section_heading" do
+    it "returns nil when not provided" do
+      chunk_without_section_header.section_header.should be_nil
+    end
+    it "returns the correct value when it is provided" do
+      chunk.section_header.should == "A section header"
+    end
+  end
+
+  describe "#each_line" do
+    it "iterates over each line" do
+      count = 0
+      chunk.each_line do |line|
+        count += 1
+      end
+
+      expect(count).to eq lines.length
+    end
+
+    it "passes the line as block argument" do
+      index = 0
+      chunk.each_line do |line|
+        expect(line).to be_a_kind_of Unified::Line
+        line.should == lines[index]
+        index += 1
+      end
+    end
+
+    it "passes the original line number as a block argument" do
+      expected_line_numbers = [1, nil, 2, nil, 3, 4]
+      index = 0
+      chunk.each_line do |line, original_line_number|
+        original_line_number.should == expected_line_numbers[index]
+        index += 1
+      end
+    end
+
+    it "passes the modified line number as a block argument" do
+      expected_line_numbers = [2, 3, nil, 4, nil, 5]
+      index = 0
+      chunk.each_line do |line, original_line_number, modified_line_number|
+        modified_line_number.should == expected_line_numbers[index]
+        index += 1
+      end
+    end
+  end
+
+  describe "#==" do
+    it "returns true when both line numbers and all lines are equal" do
+      another_chunk = Unified::Chunk.new original: 1, modified: 2, lines: lines, section_header: "A section header"
+      chunk.should == another_chunk
+    end
+  end
+
+  describe "#header" do
+    it "returns a valid chunk header" do
+      chunk_without_section_header.header.should == "@@ -1,4 +2,4 @@"
+    end
+    it "returns a valid chunk header with section heading" do
+      chunk.header.should == "@@ -1,4 +2,4 @@ A section header"
+    end
+    it "does not display number of lines if it is 1" do
+      chunk = Unified::Chunk.new original: 1, modified: 1, lines: [" Line 1"]
+      chunk.header.should == "@@ -1 +1 @@"
+    end
+  end
+
+  describe "#to_s" do
+    it "outputs the chunk header followed by each line" do
+      chunk.to_s.should == <<-EOF.strip
+@@ -1,4 +2,4 @@ A section header
+ Line 1
++Line 2
+-Line 3
++Line4
+-Line5
+ Line6
+EOF
+    end
+  end
+end