pretty_diff 0.9.3 → 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2b6469b15bc93eef7d745c13cb407cf7ed005b34
+  data.tar.gz: 30836b4814f14cf92ea0032be12daf987259b311
+SHA512:
+  metadata.gz: 8d4df170603a0a29963cc321bd292110107374e0f37bd1ae89cb76254cadcf10d52f0f956cc20987d81eb83cf2687dcbc4761cd3ff16aed0bc6c43a93a071431
+  data.tar.gz: 92f7e156c4e5fbfcff6b23f749c656a4d9c29d03b4344d321df1addfc0a8e08239f7b71c56f0985a194d417667924bb1da6e603c916bf1b796aebe5cd944f455

data/Gemfile

@@ -1,5 +1,7 @@
 source "http://rubygems.org"
 
+gem "charlock_holmes", "~> 0.6"
+
 group :development do
   gem "jeweler"
   gem "builder"

data/Gemfile.lock

@@ -1,16 +1,50 @@
 GEM
   remote: http://rubygems.org/
   specs:
+    addressable (2.3.5)
     builder (3.1.4)
-    git (1.2.5)
-    jeweler (1.8.4)
-      bundler (~> 1.0)
+    charlock_holmes (0.6.9.1)
+    descendants_tracker (0.0.3)
+    faraday (0.9.0)
+      multipart-post (>= 1.2, < 3)
+    git (1.2.6)
+    github_api (0.11.2)
+      addressable (~> 2.3)
+      descendants_tracker (~> 0.0.1)
+      faraday (~> 0.8, < 0.10)
+      hashie (>= 1.2)
+      multi_json (>= 1.7.5, < 2.0)
+      nokogiri (~> 1.6.0)
+      oauth2
+    hashie (2.0.5)
+    highline (1.6.20)
+    jeweler (2.0.1)
+      builder
+      bundler (>= 1.0)
       git (>= 1.2.5)
+      github_api
+      highline (>= 1.6.15)
+      nokogiri (>= 1.5.10)
       rake
       rdoc
-    json (1.7.7)
-    rake (10.0.4)
-    rdoc (4.0.1)
+    json (1.8.1)
+    jwt (0.1.11)
+      multi_json (>= 1.5)
+    mini_portile (0.5.2)
+    multi_json (1.8.4)
+    multi_xml (0.5.5)
+    multipart-post (2.0.0)
+    nokogiri (1.6.1)
+      mini_portile (~> 0.5.0)
+    oauth2 (0.9.3)
+      faraday (>= 0.8, < 0.10)
+      jwt (~> 0.1.8)
+      multi_json (~> 1.3)
+      multi_xml (~> 0.5)
+      rack (~> 1.2)
+    rack (1.5.2)
+    rake (10.1.1)
+    rdoc (4.1.1)
       json (~> 1.4)
 
 PLATFORMS
@@ -18,4 +52,5 @@ PLATFORMS
 
 DEPENDENCIES
   builder
+  charlock_holmes (~> 0.6)
   jeweler

data/Rakefile

@@ -29,5 +29,4 @@ Rake::TestTask.new(:test) do |test|
   test.verbose = true
 end
 
-task :test => :check_dependencies
 task :default => :test

data/VERSION

@@ -1 +1 @@
-0.9.3
+2.0.0

data/lib/pretty_diff.rb

@@ -1,16 +1,15 @@
-module PrettyDiff #:nodoc:
+module PrettyDiff
+  class InvalidGenerator < Exception; end
 end
 
 def require_local(suffix)
   require(File.expand_path(File.join(File.dirname(__FILE__), suffix)))
 end
 
+require_local 'pretty_diff/encoding'
 require_local 'pretty_diff/diff'
 require_local 'pretty_diff/chunk'
 require_local 'pretty_diff/line_numbers'
 require_local 'pretty_diff/line'
-
-require_local 'pretty_diff/html_generators/diff_generator'
-require_local 'pretty_diff/html_generators/chunk_generator'
-require_local 'pretty_diff/html_generators/line_generator'
-require_local 'pretty_diff/html_generators/line_numbers_generator'
+require_local 'pretty_diff/abstract_generator'
+require_local 'pretty_diff/basic_generator'

data/lib/pretty_diff/abstract_generator.rb

@@ -0,0 +1,51 @@
+require 'cgi'
+
+module PrettyDiff
+  class AbstractGenerator
+
+    def self.[](tgt)
+      new(tgt)
+    end
+
+    def initialize(tgt)
+      target_name = class_to_target_name(tgt.class)
+      instance_variable_set("@#{target_name}", tgt)
+      self.class.class_eval do
+        attr_accessor(target_name)
+      end
+    end
+
+    def generate
+      raise 'Not implemented!'
+    end
+
+  protected
+
+    def tag(name, options=nil, open=false)
+      "<#{name}#{tag_options(options) if options}#{open ? ">" : " />"}"
+    end
+
+    def content_tag(name, options=nil, &block)
+      "<#{name}#{tag_options(options) if options}>#{block.call}</#{name}>"
+    end
+
+    def tag_options(options)
+      return if options.empty?
+      attrs = []
+      options.each_pair do |key, value|
+        unless value.nil?
+          attrs << %(#{key}="#{h(value)}")
+        end
+      end
+      " #{attrs.sort * ' '}" unless attrs.empty?
+    end
+
+    def h(t)
+      CGI.escapeHTML(t)
+    end
+
+    def class_to_target_name(c)
+      c.to_s.split('::').last.gsub(/Gen(erator)?\z/, '').gsub(/(.)([A-Z])/,'\1_\2').downcase
+    end
+  end
+end

data/lib/pretty_diff/basic_generator.rb

@@ -0,0 +1,72 @@
+module PrettyDiff
+  class BasicGenerator < AbstractGenerator
+
+    def generate
+      content_tag :div, :class => 'diff' do
+        diff.chunks.map{|c| ChunkGen[c].generate}.join('')
+      end
+    end
+
+    class ChunkGen < PrettyDiff::AbstractGenerator
+      def generate
+        content_tag :div, :class => 'diff-chunk' do
+          numbers + code
+        end
+      end
+
+    private
+
+      def numbers
+        LineNumbersGen[chunk.line_numbers].generate
+      end
+
+      def code
+        content_tag :div, :class => 'diff-code' do
+          content_tag :pre do
+            chunk.lines.map{|l| LineGen[l].generate }.join("\n")        
+          end
+        end
+      end
+    end
+
+    class LineNumbersGen < PrettyDiff::AbstractGenerator
+      def generate
+        column(line_numbers.left_column) + column(line_numbers.right_column)
+      end
+
+    private
+
+      def column(clmn)
+        content_tag :div, :class => 'diff-line-nums' do
+          content_tag :pre do
+            fill_whitespace(clmn).join("\n")    
+          end
+        end
+      end
+      
+      def fill_whitespace(numbers)
+        [].tap do |filled|
+          numbers.each do |v|
+            filled << (v.nil? ? '&nbsp;' : v)
+          end
+        end
+      end
+    end
+
+    class LineGen < PrettyDiff::AbstractGenerator
+      def generate
+        if line.added?
+          content_tag(:span, :class => 'diff-line-add') do
+            h(line.contents)
+          end
+        elsif line.deleted?
+          content_tag(:span, :class => 'diff-line-del') do
+            h(line.contents)
+          end
+        else
+          h(line.contents)
+        end
+      end
+    end
+  end
+end

data/lib/pretty_diff/chunk.rb

@@ -1,49 +1,32 @@
-#
-# Represent a single piece of a diff.
-#
-class PrettyDiff::Chunk #:nodoc:
-  attr_reader :diff, :meta_info, :input, :lines
+module PrettyDiff
+  class Chunk
+    attr_reader :diff, :meta_info, :lines, :contents
 
-  def initialize(diff, meta_info, input)
-    @diff = diff
-    @meta_info = meta_info
-    @input = input
-  end
-
-  # Generate HTML presentation for a Chunk. Return a string.
-  def to_html
-    # We have to find lines before we can call line numbers methods.
-    find_lines!
-    generator.generate
-  end
-
-  # Return LineNumbers object that represents two columns of numbers
-  # that will be displayed on the left of the HTML presentation.
-  #
-  # IMPORTANT! Before calling this method it's essential to call "find_lines!" first,
-  # otherwise the array will be empty.
-  def line_numbers
-    @_line_numbers ||= PrettyDiff::LineNumbers.new(diff, meta_info)
-  end
+    def initialize(diff, meta_info, contents)
+      @diff = diff
+      @meta_info = meta_info
+      @contents = contents
+      @lines = find_lines
+    end
 
-private
+    def line_numbers
+      @_line_numbers ||= LineNumbers.new(diff, meta_info)
+    end
 
-  def generator
-    @_generator ||= PrettyDiff::ChunkGenerator.new(self)
-  end
+  private
 
-  # Parse the input searching for lines. Initialize Line object for every line.
-  # Return an array of Line objects.
-  def find_lines!
-    @lines = []
-    @lines.tap do
-      input.split(/\r?\n/).each do |line_str|
-        line = PrettyDiff::Line.new(diff, line_str)
-        next if line.ignore?
-        @lines << line
-        line_numbers.act_on_line(line)
+    def find_lines
+      [].tap do |lines|
+        contents.split(/\r?\n|\r/).each do |line_str|
+          line = Line.new(self, line_str)
+          next if line.ignored?
+          lines << line
+          line_numbers.act_on_line(line)
+          line.left_number = line_numbers.left_column.last
+          line.right_number = line_numbers.right_column.last
+        end
       end
     end
-  end
 
+  end
 end

data/lib/pretty_diff/diff.rb

@@ -1,5 +1,3 @@
-require 'cgi'
-
 #
 # Main class to interact with. In fact this is the only class you should interact with
 # when using the library.
@@ -11,52 +9,88 @@ require 'cgi'
 # Keep in mind that Diff will automatically escape all HTML tags from the intput string
 # so that it doesn't interfere with the output.
 #
-class PrettyDiff::Diff
-  CHUNK_REGEXP = /^@@ .+ @@\n?/
-
-  attr_reader :input, :options
-
-  # Create new Diff object.
-  # Accept a String in unified diff format and options hash.
-  # Currrent options:
-  # * wrap_lines -- wrap each line in code block with <div> element.
-  def initialize(unified_diff, options={})
-    @input = escape_html(unified_diff)
-    @options = options
-  end
+module PrettyDiff
+  class Diff
+    CHUNK_REGEXP = /^@@ .+? @@.*\n?$/
 
-  # Generate HTML presentation. Return a string.
-  def to_html
-    generator.generate
-  end
+    attr_reader :unified_diff, :generator, :out_encoding
 
-  # Return an array of Chunk objects that Diff found in the input.
-  def chunks
-    @_chunks ||= find_chunks(input)
-  end
+    #
+    # Create new Diff object.
+    # Accept a String in unified diff format and options hash.
+    # Currrent options:
+    # * generator -- your own custom implementation of HTML generator. Will use BasicGenerator by default.
+    # * out_encoding -- convert encoding of diffs to the specififed encoding. utf-8 by default.
+    #
+    def initialize(unified_diff, options={})
+      @unified_diff = unified_diff
+      @options = options
+      @out_encoding = 
+      @generator = validate_generator(options[:generator]) || BasicGenerator
+      @out_encoding = options[:out_encoding] || 'utf-8'
+    end
 
-private
+    def metadata
+      @_metadata ||= begin
+        ''.tap do |result|
+          unified_diff.each_line do |l|
+            result << l
+            break if l =~ /^\+\+\+ /
+          end
+        end
+      end
+    end
 
-  def generator
-    @_generator ||= PrettyDiff::DiffGenerator.new(self)
-  end
+    def contents
+      # We have to strip metadata from the rest of the diff
+      # to enforce encoding. It's not uncommon for metadata to be in Unicode
+      # while the diff itself is in some other encoding.
+      @_contents ||= enforce_encoding(unified_diff.lines[metadata.lines.size..-1].join(''))
+    end
+
+    def to_html
+      generator.new(self).generate
+    end
+
+    def chunks
+      @_chunks ||= find_chunks
+    end
 
-  # Parse the input for diff chunks and initialize a Chunk object for each of them.
-  # Return an array of Chunks.
-  def find_chunks(text)
-    meta_info = text.scan(CHUNK_REGEXP)
-    chunks = []
-    chunks.tap do
-      split = text.split(CHUNK_REGEXP)
-      split.shift
-      split.each_with_index do |lines, idx|
-        chunks << PrettyDiff::Chunk.new(self, meta_info[idx], lines)
+  private
+
+    def find_chunks
+      chunks_meta = contents.scan(CHUNK_REGEXP)
+      [].tap do |chunks|
+        split = contents.split(CHUNK_REGEXP)
+        split.shift
+        split.each_with_index do |lines, index|
+          chunks << Chunk.new(self, chunks_meta[index], cleanup(lines))
+        end
       end
     end
-  end
 
-  def escape_html(input_text)
-    CGI.escapeHTML(input_text)
-  end
+    def validate_generator(gen)
+      if valid_generator?(gen)
+        gen
+      else
+        raise InvalidGenerator, "#{gen.inspect} is not a valid PrettyDiff generator"
+      end
+    end
+
+    def valid_generator?(generator)
+      !generator.nil? &&
+      generator.kind_of?(Class) &&
+      generator.ancestors.include?(PrettyDiff::AbstractGenerator) &&
+      generator.instance_methods.include?(:generate)
+    end
+
+    def enforce_encoding(text)
+      Encoding.enforce(out_encoding, text)
+    end
 
+    def cleanup(line)
+      line[1..-1]
+    end
+
+  end
 end