messagebus_ruby_api 0.4.7 → 0.4.8

data/spec/ruby/1.9.1/gems/diff-lcs-1.1.2/lib/diff/lcs/hunk.rb

@@ -1,257 +0,0 @@
-#! /usr/env/bin ruby
-#--
-# Copyright 2004 Austin Ziegler <diff-lcs@halostatue.ca>
-#   adapted from:
-#     Algorithm::Diff (Perl) by Ned Konz <perl@bike-nomad.com>
-#     Smalltalk by Mario I. Wolczko <mario@wolczko.com>
-#   implements McIlroy-Hunt diff algorithm
-#
-# 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.
-# 
-# $Id: hunk.rb,v 1.2 2004/08/08 20:33:09 austin Exp $
-#++
-# Contains Diff::LCS::Hunk for bin/ldiff.
-
-require 'diff/lcs/block'
-
-  # A Hunk is a group of Blocks which overlap because of the context
-  # surrounding each block. (So if we're not using context, every hunk will
-  # contain one block.) Used in the diff program (bin/diff).
-class Diff::LCS::Hunk
-    # Create a hunk using references to both the old and new data, as well as
-    # the piece of data
-  def initialize(data_old, data_new, piece, context, file_length_difference)
-      # At first, a hunk will have just one Block in it
-    @blocks = [ Diff::LCS::Block.new(piece) ]
-    @data_old = data_old
-    @data_new = data_new
-
-    before = after = file_length_difference
-    after += @blocks[0].diff_size
-    @file_length_difference = after # The caller must get this manually
-
-      # Save the start & end of each array. If the array doesn't exist
-      # (e.g., we're only adding items in this block), then figure out the
-      # line number based on the line number of the other file and the
-      # current difference in file lengths.
-    if @blocks[0].remove.empty?
-      a1 = a2 = nil
-    else
-      a1 = @blocks[0].remove[0].position
-      a2 = @blocks[0].remove[-1].position
-    end
-
-    if @blocks[0].insert.empty?
-      b1 = b2 = nil
-    else
-      b1 = @blocks[0].insert[0].position
-      b2 = @blocks[0].insert[-1].position
-    end
-
-    @start_old = a1 || (b1 - before)
-    @start_new = b1 || (a1 + before)
-    @end_old   = a2 || (b2 - after)
-    @end_new   = b2 || (a2 + after)
-
-    self.flag_context = context
-  end
-
-  attr_reader :blocks
-  attr_reader :start_old, :start_new
-  attr_reader :end_old, :end_new
-  attr_reader :file_length_difference
-
-    # Change the "start" and "end" fields to note that context should be added
-    # to this hunk
-  attr_accessor :flag_context
-  def flag_context=(context) #:nodoc:
-    return if context.nil? or context.zero?
-
-    add_start = (context > @start_old) ? @start_old : context
-    @start_old -= add_start
-    @start_new -= add_start
-
-    if (@end_old + context) > @data_old.size
-      add_end = @data_old.size - @end_old
-    else
-      add_end = context
-    end
-    @end_old += add_end
-    @end_new += add_end
-  end
-
-  def unshift(hunk)
-    @start_old = hunk.start_old
-    @start_new = hunk.start_new
-    blocks.unshift(*hunk.blocks)
-  end
-
-    # Is there an overlap between hunk arg0 and old hunk arg1? Note: if end
-    # of old hunk is one less than beginning of second, they overlap
-  def overlaps?(hunk = nil)
-    return nil if hunk.nil?
-
-    a = (@start_old - hunk.end_old) <= 1
-    b = (@start_new - hunk.end_new) <= 1
-    return (a or b)
-  end
-
-  def diff(format)
-    case format
-    when :old
-      old_diff
-    when :unified
-      unified_diff
-    when :context
-      context_diff
-    when :ed
-      self
-    when :reverse_ed, :ed_finish
-      ed_diff(format)
-    else
-      raise "Unknown diff format #{format}."
-    end
-  end
-
-  def each_old(block)
-    @data_old[@start_old .. @end_old].each { |e| yield e }
-  end
-
-  private
-    # Note that an old diff can't have any context. Therefore, we know that
-    # there's only one block in the hunk.
-  def old_diff
-    warn "Expecting only one block in an old diff hunk!" if @blocks.size > 1
-    op_act = { "+" => 'a', "-" => 'd', "!" => "c" }
-
-    block = @blocks[0]
-
-      # Calculate item number range. Old diff range is just like a context
-      # diff range, except the ranges are on one line with the action between
-      # them.
-    s = "#{context_range(:old)}#{op_act[block.op]}#{context_range(:new)}\n"
-      # If removing anything, just print out all the remove lines in the hunk
-      # which is just all the remove lines in the block.
-    @data_old[@start_old .. @end_old].each { |e| s << "< #{e}\n" } unless block.remove.empty?
-    s << "---\n" if block.op == "!"
-    @data_new[@start_new .. @end_new].each { |e| s << "> #{e}\n" } unless block.insert.empty?
-    s
-  end
-
-  def unified_diff
-      # Calculate item number range.
-    s = "@@ -#{unified_range(:old)} +#{unified_range(:new)} @@\n"
-
-      # Outlist starts containing the hunk of the old file. Removing an item
-      # just means putting a '-' in front of it. Inserting an item requires
-      # getting it from the new file and splicing it in. We splice in
-      # +num_added+ items. Remove blocks use +num_added+ because splicing
-      # changed the length of outlist.
-      #
-      # We remove +num_removed+ items. Insert blocks use +num_removed+
-      # because their item numbers -- corresponding to positions in the NEW
-      # file -- don't take removed items into account.
-    lo, hi, num_added, num_removed = @start_old, @end_old, 0, 0
-
-    outlist = @data_old[lo .. hi].collect { |e| e.gsub(/^/, ' ') }
-
-    @blocks.each do |block|
-      block.remove.each do |item|
-        op = item.action.to_s # -
-        offset = item.position - lo + num_added
-        outlist[offset].gsub!(/^ /, op.to_s)
-        num_removed += 1
-      end
-      block.insert.each do |item|
-        op = item.action.to_s # +
-        offset = item.position - @start_new + num_removed
-        outlist[offset, 0] = "#{op}#{@data_new[item.position]}"
-        num_added += 1
-      end
-    end
-
-    s << outlist.join("\n")
-  end
-
-  def context_diff
-    s = "***************\n"
-    s << "*** #{context_range(:old)} ****\n"
-    r = context_range(:new)
-
-      # Print out file 1 part for each block in context diff format if there
-      # are any blocks that remove items
-    lo, hi = @start_old, @end_old
-    removes = @blocks.select { |e| not e.remove.empty? }
-    if removes
-      outlist = @data_old[lo .. hi].collect { |e| e.gsub(/^/, '  ') }
-      removes.each do |block|
-        block.remove.each do |item|
-          outlist[item.position - lo].gsub!(/^ /) { block.op } # - or !
-        end
-      end
-      s << outlist.join("\n")
-    end
-
-    s << "\n--- #{r} ----\n"
-    lo, hi = @start_new, @end_new
-    inserts = @blocks.select { |e| not e.insert.empty? }
-    if inserts
-      outlist = @data_new[lo .. hi].collect { |e| e.gsub(/^/, '  ') }
-      inserts.each do |block|
-        block.insert.each do |item|
-          outlist[item.position - lo].gsub!(/^ /) { block.op } # + or !
-        end
-      end
-      s << outlist.join("\n")
-    end
-    s
-  end
-
-  def ed_diff(format)
-    op_act = { "+" => 'a', "-" => 'd', "!" => "c" }
-    warn "Expecting only one block in an old diff hunk!" if @blocks.size > 1
-
-    if format == :reverse_ed
-      s = "#{op_act[@blocks[0].op]}#{context_range(:old)}\n"
-    else
-      s = "#{context_range(:old).gsub(/,/, ' ')}#{op_act[@blocks[0].op]}\n"
-    end
-
-    unless @blocks[0].insert.empty?
-      @data_new[@start_new .. @end_new].each { |e| s << "#{e}\n" }
-      s << ".\n"
-    end
-    s
-  end
-
-    # Generate a range of item numbers to print. Only print 1 number if the
-    # range has only one item in it. Otherwise, it's 'start,end'
-  def context_range(mode)
-    case mode
-    when :old
-      s, e = (@start_old + 1), (@end_old + 1)
-    when :new
-      s, e = (@start_new + 1), (@end_new + 1)
-    end
-
-    (s < e) ? "#{s},#{e}" : "#{e}"
-  end
-
-    # Generate a range of item numbers to print for unified diff. Print
-    # number where block starts, followed by number of lines in the block
-    # (don't print number of lines if it's 1)
-  def unified_range(mode)
-    case mode
-    when :old
-      s, e = (@start_old + 1), (@end_old + 1)
-    when :new
-      s, e = (@start_new + 1), (@end_new + 1)
-    end
-
-    length = e - s + 1
-    first = (length < 2) ? e : s # "strange, but correct"
-    (length == 1) ? "#{first}" : "#{first},#{length}"
-  end
-end

data/spec/ruby/1.9.1/gems/diff-lcs-1.1.2/lib/diff/lcs/ldiff.rb

@@ -1,226 +0,0 @@
-#!/usr/bin/env ruby
-
-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 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.
-
-$Id: ldiff.rb,v 1.1 2004/09/26 01:37:49 austin Exp $
-              COPYRIGHT
-  
-  class << self
-    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:
-      args.options do |o|
-        o.banner = "Usage: #{File.basename($0)} [options] oldfile newfile"
-        o.separator ""
-        o.on('-c',
-            'Displays a context diff with 3 lines of',
-            'context.') do |ctx|
-          @format = :context
-          @lines  = 3
-        end
-        o.on('-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',
-            'Displays a unified diff with 3 lines of',
-            'context.') do |ctx|
-          @format = :unified
-          @lines  = 3
-        end
-        o.on('-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].grep(/\0/).empty?
-          new_txt = data_new[0...4096].grep(/\0/).empty?
-          @binary = (not old_txt) or (not new_txt)
-          old_txt = new_txt = nil
-        end
-
-        unless @binary
-          data_old = data_old.split(/\n/).map! { |e| e.chomp }
-          data_new = data_new.split(/\n/).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) and diffs
-        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 %z')
-        puts "#{char_old} #{file_old}\t#{ft}"
-        ft = File.stat(file_new).mtime.localtime.strftime('%Y-%m-%d %H:%M:%S %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
-
-        if (@lines > 0) and hunk.overlaps?(oldhunk)
-          hunk.unshift(oldhunk)
-        else
-          output << oldhunk.diff(@format)
-        end
-      ensure
-        oldhunk = hunk
-        output << "\n"
-      end
-      end
-
-      output << oldhunk.diff(@format)
-      output << "\n"
-
-      if @format == :ed
-        output.reverse_each { |e| real_output << e.diff(:ed_finish) }
-      end
-
-      return 1
-    end
-  end
-end