leg 0.0.1 → 0.0.2

data/lib/leg/diff.rb

@@ -0,0 +1,151 @@
+module Leg
+  class Diff
+    attr_accessor :filename, :is_new_file, :lines
+
+    def initialize(filename = nil, is_new_file = false, lines = [])
+      @filename = filename
+      @is_new_file = is_new_file
+      @lines = lines
+    end
+
+    def clone
+      Leg::Diff.new(@filename.dup, @is_new_file, @lines.map(&:clone))
+    end
+
+    def clone_empty
+      Leg::Diff.new(@filename.dup, @is_new_file, [])
+    end
+
+    # Append a Line to the Diff.
+    def <<(line)
+      unless line.is_a? Leg::Line
+        raise ArgumentError, "expected a Line"
+      end
+      @lines << line
+      self
+    end
+
+    def to_patch(options = {})
+      patch = ""
+      patch += "diff --git a/#{@filename} b/#{@filename}\n" unless options[:strip_git_lines]
+      if @is_new_file
+        patch += "new file mode 100644\n" unless options[:strip_git_lines]
+        patch += "--- /dev/null\n"
+      else
+        patch += "--- #{'a/' unless options[:strip_git_lines]}#{@filename}\n"
+      end
+      patch += "+++ #{'b/' unless options[:strip_git_lines]}#{@filename}\n"
+
+      find_hunks.each do |hunk|
+        patch += hunk_header(hunk)
+        hunk.each do |line|
+          patch += line.to_patch(options)
+        end
+      end
+
+      patch
+    end
+
+    # Parse a git diff and return an array of Diff objects, one for each file in
+    # the git diff.
+    def self.parse(git_diff)
+      in_diff = false
+      old_line_num = nil
+      new_line_num = nil
+      cur_diff = nil
+      diffs = []
+
+      git_diff.lines.each do |line|
+        if line =~ /^--- (.+)$/
+          cur_diff = Leg::Diff.new
+          if $1 == '/dev/null'
+            cur_diff.is_new_file = true
+          end
+          diffs << cur_diff
+          in_diff = false
+        elsif line =~ /^\+\+\+ (.+)$/
+          cur_diff.filename = $1.strip.sub(/^b\//, '')
+        elsif line =~ /^@@ -(\d+)(,\d+)? \+(\d+)(,\d+)? @@/
+          # TODO: somehow preserve function name that comes to the right of the @@ header?
+          in_diff = true
+          old_line_num = $1.to_i
+          new_line_num = $3.to_i
+        elsif in_diff && line[0] == '\\'
+          # Ignore "".
+        elsif in_diff && [' ', '|', '+', '-'].include?(line[0])
+          case line[0]
+          when ' ', '|'
+            line_nums = [old_line_num, new_line_num]
+            old_line_num += 1
+            new_line_num += 1
+            cur_diff << Leg::Line::Unchanged.new(line[1..-1], line_nums)
+          when '+'
+            line_nums = [nil, new_line_num]
+            new_line_num += 1
+            cur_diff << Leg::Line::Added.new(line[1..-1], line_nums)
+          when '-'
+            line_nums = [old_line_num, nil]
+            old_line_num += 1
+            cur_diff << Leg::Line::Removed.new(line[1..-1], line_nums)
+          end
+        else
+          in_diff = false
+        end
+      end
+
+      diffs
+    end
+
+    private
+
+    # :S
+    def hunk_header(hunk)
+      old_line, new_line = hunk.first.line_numbers
+      old_line ||= 1
+      new_line ||= 1
+
+      old_count = hunk.count { |line| [Leg::Line::Removed, Leg::Line::Unchanged].include? line.class }
+      new_count = hunk.count { |line| [Leg::Line::Added, Leg::Line::Unchanged].include? line.class }
+
+      old_line = 0 if old_count == 0
+      new_line = 0 if new_count == 0
+
+      "@@ -#{old_line},#{old_count} +#{new_line},#{new_count} @@\n"
+    end
+
+    # :(
+    def find_hunks
+      raise "can't create patch from empty diff" if @lines.empty?
+      hunks = []
+      cur_hunk = [@lines.first]
+      cur_line_nums = @lines.first.line_numbers.dup
+      @lines[1..-1].each do |line|
+        case line
+        when Leg::Line::Unchanged
+          cur_line_nums[0] = cur_line_nums[0].nil? ? line.line_numbers[0] : (cur_line_nums[0] + 1)
+          cur_line_nums[1] = cur_line_nums[1].nil? ? line.line_numbers[1] : (cur_line_nums[1] + 1)
+        when Leg::Line::Added
+          cur_line_nums[1] = cur_line_nums[1].nil? ? line.line_numbers[1] : (cur_line_nums[1] + 1)
+        when Leg::Line::Removed
+          cur_line_nums[0] = cur_line_nums[0].nil? ? line.line_numbers[0] : (cur_line_nums[0] + 1)
+        when Leg::Line::Folded
+          raise "can't create patch from diff with folded lines"
+        end
+
+        old_match = (line.line_numbers[0].nil? || line.line_numbers[0] == cur_line_nums[0])
+        new_match = (line.line_numbers[1].nil? || line.line_numbers[1] == cur_line_nums[1])
+
+        if !old_match || !new_match
+          hunks << cur_hunk
+
+          cur_hunk = []
+          cur_line_nums = line.line_numbers.dup
+        end
+
+        cur_hunk << line
+      end
+      hunks << cur_hunk
+      hunks
+    end
+  end
+end

data/lib/leg/diff_transformers.rb

@@ -0,0 +1,11 @@
+require 'leg/diff_transformers/base_transformer'
+
+require 'leg/diff_transformers/fold_sections'
+require 'leg/diff_transformers/omit_adjacent_removals'
+require 'leg/diff_transformers/syntax_highlight'
+require 'leg/diff_transformers/trim_blank_lines'
+
+module Leg
+  module DiffTransformers
+  end
+end

data/lib/leg/diff_transformers/base_transformer.rb

@@ -0,0 +1,13 @@
+module Leg
+  module DiffTransformers
+    class BaseTransformer
+      def initialize(options = {})
+        @options = options
+      end
+
+      def transform(diff)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/leg/diff_transformers/fold_sections.rb

@@ -0,0 +1,89 @@
+module Leg
+  module DiffTransformers
+    class FoldSections < BaseTransformer
+      def transform(diff)
+        sections = @options[:section_types].map { [] }
+
+        cur_sections = @options[:section_types].map { nil }
+        diff.lines.each.with_index do |line, idx|
+          @options[:section_types].each.with_index do |section_type, level|
+            if line.source =~ Regexp.new(section_type[:start])
+              if !section_type[:end] && cur_sections[level]
+                cur_sections[level].end_line = idx - 1
+                if @options[:unfold_before_new_section]
+                  cur_sections[level].dirty! if [:added, :removed].include? line.type
+                end
+                sections[level] << cur_sections[level]
+              end
+
+              cur_sections[level] = Section.new(level, idx)
+
+              if [:added, :removed].include? line.type
+                cur_sections[level].dirty!
+              end
+            elsif section_type[:end] && line.source =~ Regexp.new(section_type[:end])
+              if [:added, :removed].include? line.type
+                cur_sections[level].dirty!
+              end
+
+              cur_sections[level].end_line = idx
+              sections[level] << cur_sections[level]
+              cur_sections[level] = nil
+            elsif cur_sections[level]
+              if [:added, :removed].include? line.type
+                cur_sections[level].dirty!
+              end
+            end
+          end
+        end
+        cur_sections.each.with_index do |section, level|
+          unless section.nil?
+            section.end_line = diff.lines.length - 1
+            sections[level] << section
+          end
+        end
+
+        new_diff = diff.clone
+        sections.each.with_index do |level_sections, level|
+          level_sections.each do |section|
+            if !section.dirty? && !new_diff.lines[section.to_range].any?(&:nil?)
+              start_line = new_diff.lines[section.start_line]
+              end_line = new_diff.lines[section.end_line]
+
+              summary_lines = [start_line]
+              summary_lines << end_line if @options[:section_types][level][:end]
+              summary = summary_lines.map(&:source).join(" … ")
+
+              line_numbers = [start_line.line_number, end_line.line_number]
+
+              folded_line = Leg::Line::Folded.new(summary, line_numbers)
+
+              section.to_range.each do |idx|
+                new_diff.lines[idx] = nil
+              end
+
+              new_diff.lines[section.start_line] = folded_line
+            end
+          end
+        end
+        new_diff.lines.compact!
+        new_diff
+      end
+
+      class Section
+        attr_accessor :level, :start_line, :end_line, :dirty
+
+        def initialize(level, start_line, end_line = nil, dirty = false)
+          @level, @start_line, @end_line, @dirty = level, start_line, end_line, dirty
+        end
+
+        def to_range
+          start_line..end_line
+        end
+
+        def dirty?; @dirty; end
+        def dirty!; @dirty = true; end
+      end
+    end
+  end
+end

data/lib/leg/diff_transformers/omit_adjacent_removals.rb

@@ -0,0 +1,38 @@
+module Leg
+  module DiffTransformers
+    class OmitAdjacentRemovals < BaseTransformer
+      def transform(diff)
+        new_diff = diff.clone
+
+        removed_lines = []
+        saw_added_line = false
+        new_diff.lines.each.with_index do |line, idx|
+          case line.type
+          when :unchanged, :folded
+            if saw_added_line
+              removed_lines.each do |removed_idx|
+                new_diff.lines[removed_idx] = nil
+              end
+            end
+
+            removed_lines = []
+            saw_added_line = false
+          when :added
+            saw_added_line = true
+          when :removed
+            removed_lines << idx
+          end
+        end
+
+        if saw_added_line
+          removed_lines.each do |removed_idx|
+            new_diff.lines[removed_idx] = nil
+          end
+        end
+
+        new_diff.lines.compact!
+        new_diff
+      end
+    end
+  end
+end

data/lib/leg/diff_transformers/syntax_highlight.rb

@@ -0,0 +1,32 @@
+module Leg
+  module DiffTransformers
+    class SyntaxHighlight < BaseTransformer
+      class HTMLLineByLine < Rouge::Formatter
+        def initialize(formatter)
+          @formatter = formatter
+        end
+
+        def stream(tokens, &b)
+          token_lines(tokens) do |line|
+            line.each do |tok, val|
+              yield @formatter.span(tok, val)
+            end
+            yield "\n"
+          end
+        end
+      end
+
+      SYNTAX_HIGHLIGHTER = HTMLLineByLine.new(Rouge::Formatters::HTML.new)
+
+      def transform(diff)
+        new_diff = diff.clone
+        code = new_diff.lines.map(&:source).join("\n") + "\n"
+        lexer = Rouge::Lexer.guess(filename: new_diff.filename, source: code)
+        SYNTAX_HIGHLIGHTER.format(lexer.lex(code)).lines.each.with_index do |line_hl, idx|
+          new_diff.lines[idx].source = line_hl
+        end
+        new_diff
+      end
+    end
+  end
+end

data/lib/leg/diff_transformers/trim_blank_lines.rb

@@ -0,0 +1,25 @@
+module Leg
+  module DiffTransformers
+    class TrimBlankLines < BaseTransformer
+      def transform(diff)
+        new_diff = diff.clone_empty
+        diff.lines.each.with_index do |line, idx|
+          line = line.clone
+          if line.blank? && [:added, :removed].include?(line.type)
+            prev_line = idx > 0 ? diff.lines[idx - 1] : nil
+            next_line = idx < diff.lines.length - 1 ? diff.lines[idx + 1] : nil
+
+            prev_changed = prev_line && [:added, :removed].include?(prev_line.type)
+            next_changed = next_line && [:added, :removed].include?(next_line.type)
+
+            if !prev_changed || !next_changed
+              line = Leg::Line::Unchanged.new(line.source, line.line_numbers)
+            end
+          end
+          new_diff.lines << line
+        end
+        new_diff
+      end
+    end
+  end
+end

data/lib/leg/line.rb

@@ -0,0 +1,83 @@
+module Leg
+  class Line
+    attr_accessor :source, :line_numbers
+
+    def initialize(source, line_numbers)
+      @source = source.chomp
+      @line_numbers = line_numbers
+    end
+
+    def clone
+      self.class.new(@source.dup, @line_numbers.dup)
+    end
+
+    def blank?
+      @source.strip.empty?
+    end
+
+    def line_number
+      raise NotImplementedError
+    end
+
+    def to_patch(options = {})
+      raise NotImplementedError
+    end
+
+    class Added < Line
+      def type
+        :added
+      end
+
+      def line_number
+        @line_numbers[1]
+      end
+
+      def to_patch(options = {})
+        "+#{@source}\n"
+      end
+    end
+
+    class Removed < Line
+      def type
+        :removed
+      end
+
+      def line_number
+        @line_numbers[0]
+      end
+
+      def to_patch(options = {})
+        "-#{@source}\n"
+      end
+    end
+
+    class Unchanged < Line
+      def type
+        :unchanged
+      end
+
+      def line_number
+        @line_numbers[1]
+      end
+
+      def to_patch(options = {})
+        char = options[:unchanged_char] || " "
+        "#{char}#{@source}\n"
+      end
+    end
+
+    class Folded < Line
+      def type
+        :folded
+      end
+
+      def line_number
+        @line_numbers[0]
+      end
+
+      def to_patch(options = {})
+        raise "can't convert folded line to patch"
+      end
+    end
+  end
+end