messagebus_ruby_api 0.4.7 → 0.4.8

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

@@ -1,21 +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: array.rb,v 1.3 2004/08/08 20:33:09 austin Exp $
-#++
-# Includes Diff::LCS into the Array built-in class.
-
-require 'diff/lcs'
-
-class Array
-  include Diff::LCS
-end

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

@@ -1,51 +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: block.rb,v 1.3 2004/08/08 20:33:09 austin Exp $
-#++
-# Contains Diff::LCS::Block for bin/ldiff.
-
-  # A block is an operation removing, adding, or changing a group of items.
-  # Basically, this is just a list of changes, where each change adds or
-  # deletes a single item. Used by bin/ldiff.
-class Diff::LCS::Block
-  attr_reader :changes, :insert, :remove
-
-  def initialize(chunk)
-    @changes = []
-    @insert = []
-    @remove = []
-
-    chunk.each do |item|
-      @changes << item
-      @remove << item if item.deleting?
-      @insert << item if item.adding?
-    end
-  end
-
-  def diff_size
-    @insert.size - @remove.size
-  end
-
-  def op
-    case [@remove.empty?, @insert.empty?]
-    when [false, false]
-      '!'
-    when [false, true]
-      '-'
-    when [true, false]
-      '+'
-    else # [true, true]
-      '^'
-    end
-  end
-end

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

@@ -1,322 +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: callbacks.rb,v 1.4 2004/09/14 18:51:26 austin Exp $
-#++
-# Contains definitions for all default callback objects.
-
-require 'diff/lcs/change'
-
-module Diff::LCS
-    # This callback object implements the default set of callback events, which
-    # only returns the event itself. Note that #finished_a and #finished_b are
-    # not implemented -- I haven't yet figured out where they would be useful.
-    #
-    # Note that this is intended to be called as is, e.g.,
-    #
-    #     Diff::LCS.LCS(seq1, seq2, Diff::LCS::DefaultCallbacks)
-  class DefaultCallbacks
-    class << self
-        # Called when two items match.
-      def match(event)
-        event
-      end
-        # Called when the old value is discarded in favour of the new value.
-      def discard_a(event)
-        event
-      end
-        # Called when the new value is discarded in favour of the old value.
-      def discard_b(event)
-        event
-      end
-        # Called when both the old and new values have changed.
-      def change(event)
-        event
-      end
-
-      private :new
-    end
-  end
-
-    # An alias for DefaultCallbacks that is used in Diff::LCS#traverse_sequences.
-    #
-    #     Diff::LCS.LCS(seq1, seq2, Diff::LCS::SequenceCallbacks)
-  SequenceCallbacks = DefaultCallbacks
-    # An alias for DefaultCallbacks that is used in Diff::LCS#traverse_balanced.
-    #
-    #     Diff::LCS.LCS(seq1, seq2, Diff::LCS::BalancedCallbacks)
-  BalancedCallbacks = DefaultCallbacks
-end
-
-  # This will produce a compound array of simple diff change objects. Each
-  # element in the #diffs array is a +hunk+ or +hunk+ array, where each
-  # element in each +hunk+ array is a single Change object representing the
-  # addition or removal of a single element from one of the two tested
-  # sequences. The +hunk+ provides the full context for the changes.
-  #
-  #     diffs = Diff::LCS.diff(seq1, seq2)
-  #       # This example shows a simplified array format.
-  #       # [ [ [ '-',  0, 'a' ] ],   # 1
-  #       #   [ [ '+',  2, 'd' ] ],   # 2
-  #       #   [ [ '-',  4, 'h' ],     # 3
-  #       #     [ '+',  4, 'f' ] ],
-  #       #   [ [ '+',  6, 'k' ] ],   # 4
-  #       #   [ [ '-',  8, 'n' ],     # 5
-  #       #     [ '-',  9, 'p' ],
-  #       #     [ '+',  9, 'r' ],
-  #       #     [ '+', 10, 's' ],
-  #       #     [ '+', 11, 't' ] ] ]
-  #
-  # There are five hunks here. The first hunk says that the +a+ at position 0
-  # of the first sequence should be deleted (<tt>'-'</tt>). The second hunk
-  # says that the +d+ at position 2 of the second sequence should be inserted
-  # (<tt>'+'</tt>). The third hunk says that the +h+ at position 4 of the
-  # first sequence should be removed and replaced with the +f+ from position 4
-  # of the second sequence. The other two hunks are described similarly.
-  #
-  # === Use
-  # This callback object must be initialised and is used by the Diff::LCS#diff
-  # method.
-  #
-  #     cbo = Diff::LCS::DiffCallbacks.new
-  #     Diff::LCS.LCS(seq1, seq2, cbo)
-  #     cbo.finish
-  #
-  # Note that the call to #finish is absolutely necessary, or the last set of
-  # changes will not be visible. Alternatively, can be used as:
-  #
-  #     cbo = Diff::LCS::DiffCallbacks.new { |tcbo| Diff::LCS.LCS(seq1, seq2, tcbo) }
-  #
-  # The necessary #finish call will be made.
-  #
-  # === Simplified Array Format
-  # The simplified array format used in the example above can be obtained
-  # with:
-  #
-  #     require 'pp'
-  #     pp diffs.map { |e| e.map { |f| f.to_a } }
-class Diff::LCS::DiffCallbacks
-    # Returns the difference set collected during the diff process.
-  attr_reader :diffs
-
-  def initialize # :yields self:
-    @hunk = []
-    @diffs = []
-
-    if block_given?
-      begin
-        yield self
-      ensure
-        self.finish
-      end
-    end
-  end
-
-    # Finalizes the diff process. If an unprocessed hunk still exists, then it
-    # is appended to the diff list.
-  def finish
-    add_nonempty_hunk
-  end
-
-  def match(event)
-    add_nonempty_hunk
-  end
-
-  def discard_a(event)
-    @hunk << Diff::LCS::Change.new('-', event.old_position, event.old_element)
-  end
-
-  def discard_b(event)
-    @hunk << Diff::LCS::Change.new('+', event.new_position, event.new_element)
-  end
-
-private
-  def add_nonempty_hunk
-    @diffs << @hunk unless @hunk.empty?
-    @hunk = []
-  end
-end
-
-  # This will produce a compound array of contextual diff change objects. Each
-  # element in the #diffs array is a "hunk" array, where each element in each
-  # "hunk" array is a single change. Each change is a Diff::LCS::ContextChange
-  # that contains both the old index and new index values for the change. The
-  # "hunk" provides the full context for the changes. Both old and new objects
-  # will be presented for changed objects. +nil+ will be substituted for a
-  # discarded object.
-  #
-  #     seq1 = %w(a b c e h j l m n p)
-  #     seq2 = %w(b c d e f j k l m r s t)
-  #
-  #     diffs = Diff::LCS.diff(seq1, seq2, Diff::LCS::ContextDiffCallbacks)
-  #       # This example shows a simplified array format.
-  #       # [ [ [ '-', [  0, 'a' ], [  0, nil ] ] ],   # 1
-  #       #   [ [ '+', [  3, nil ], [  2, 'd' ] ] ],   # 2
-  #       #   [ [ '-', [  4, 'h' ], [  4, nil ] ],     # 3
-  #       #     [ '+', [  5, nil ], [  4, 'f' ] ] ],
-  #       #   [ [ '+', [  6, nil ], [  6, 'k' ] ] ],   # 4
-  #       #   [ [ '-', [  8, 'n' ], [  9, nil ] ],     # 5
-  #       #     [ '+', [  9, nil ], [  9, 'r' ] ],
-  #       #     [ '-', [  9, 'p' ], [ 10, nil ] ],
-  #       #     [ '+', [ 10, nil ], [ 10, 's' ] ],
-  #       #     [ '+', [ 10, nil ], [ 11, 't' ] ] ] ]
-  #
-  # The five hunks shown are comprised of individual changes; if there is a
-  # related set of changes, they are still shown individually.
-  #
-  # This callback can also be used with Diff::LCS#sdiff, which will produce
-  # results like:
-  #
-  #     diffs = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextCallbacks)
-  #       # This example shows a simplified array format.
-  #       # [ [ [ "-", [  0, "a" ], [  0, nil ] ] ],  # 1
-  #       #   [ [ "+", [  3, nil ], [  2, "d" ] ] ],  # 2
-  #       #   [ [ "!", [  4, "h" ], [  4, "f" ] ] ],  # 3
-  #       #   [ [ "+", [  6, nil ], [  6, "k" ] ] ],  # 4
-  #       #   [ [ "!", [  8, "n" ], [  9, "r" ] ],    # 5
-  #       #     [ "!", [  9, "p" ], [ 10, "s" ] ],
-  #       #     [ "+", [ 10, nil ], [ 11, "t" ] ] ] ]
-  #
-  # The five hunks are still present, but are significantly shorter in total
-  # presentation, because changed items are shown as changes ("!") instead of
-  # potentially "mismatched" pairs of additions and deletions.
-  #
-  # The result of this operation is similar to that of
-  # Diff::LCS::SDiffCallbacks. They may be compared as:
-  #
-  #     s = Diff::LCS.sdiff(seq1, seq2).reject { |e| e.action == "=" }
-  #     c = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextDiffCallbacks).flatten
-  #
-  #     s == c # -> true
-  #
-  # === Use
-  # This callback object must be initialised and can be used by the
-  # Diff::LCS#diff or Diff::LCS#sdiff methods.
-  #
-  #     cbo = Diff::LCS::ContextDiffCallbacks.new
-  #     Diff::LCS.LCS(seq1, seq2, cbo)
-  #     cbo.finish
-  #
-  # Note that the call to #finish is absolutely necessary, or the last set of
-  # changes will not be visible. Alternatively, can be used as:
-  #
-  #     cbo = Diff::LCS::ContextDiffCallbacks.new { |tcbo| Diff::LCS.LCS(seq1, seq2, tcbo) }
-  #
-  # The necessary #finish call will be made.
-  #
-  # === Simplified Array Format
-  # The simplified array format used in the example above can be obtained
-  # with:
-  #
-  #     require 'pp'
-  #     pp diffs.map { |e| e.map { |f| f.to_a } }
-class Diff::LCS::ContextDiffCallbacks < Diff::LCS::DiffCallbacks
-  def discard_a(event)
-    @hunk << Diff::LCS::ContextChange.simplify(event)
-  end
-
-  def discard_b(event)
-    @hunk << Diff::LCS::ContextChange.simplify(event)
-  end
-
-  def change(event)
-    @hunk << Diff::LCS::ContextChange.simplify(event)
-  end
-end
-
-  # This will produce a simple array of diff change objects. Each element in
-  # the #diffs array is a single ContextChange. In the set of #diffs provided
-  # by SDiffCallbacks, both old and new objects will be presented for both
-  # changed <strong>and unchanged</strong> objects. +nil+ will be substituted
-  # for a discarded object.
-  #
-  # The diffset produced by this callback, when provided to Diff::LCS#sdiff,
-  # will compute and display the necessary components to show two sequences
-  # and their minimized differences side by side, just like the Unix utility
-  # +sdiff+.
-  # 
-  #     same             same
-  #     before     |     after
-  #     old        <     -
-  #     -          >     new
-  #
-  #     seq1 = %w(a b c e h j l m n p)
-  #     seq2 = %w(b c d e f j k l m r s t)
-  #
-  #     diffs = Diff::LCS.sdiff(seq1, seq2)
-  #       # This example shows a simplified array format.
-  #       # [ [ "-", [  0, "a"], [  0, nil ] ],
-  #       #   [ "=", [  1, "b"], [  0, "b" ] ],
-  #       #   [ "=", [  2, "c"], [  1, "c" ] ],
-  #       #   [ "+", [  3, nil], [  2, "d" ] ],
-  #       #   [ "=", [  3, "e"], [  3, "e" ] ],
-  #       #   [ "!", [  4, "h"], [  4, "f" ] ],
-  #       #   [ "=", [  5, "j"], [  5, "j" ] ],
-  #       #   [ "+", [  6, nil], [  6, "k" ] ],
-  #       #   [ "=", [  6, "l"], [  7, "l" ] ],
-  #       #   [ "=", [  7, "m"], [  8, "m" ] ],
-  #       #   [ "!", [  8, "n"], [  9, "r" ] ],
-  #       #   [ "!", [  9, "p"], [ 10, "s" ] ],
-  #       #   [ "+", [ 10, nil], [ 11, "t" ] ] ]
-  #
-  # The result of this operation is similar to that of
-  # Diff::LCS::ContextDiffCallbacks. They may be compared as:
-  #
-  #     s = Diff::LCS.sdiff(seq1, seq2).reject { |e| e.action == "=" }
-  #     c = Diff::LCS.sdiff(seq1, seq2, Diff::LCS::ContextDiffCallbacks).flatten
-  #
-  #     s == c # -> true
-  #
-  # === Use
-  # This callback object must be initialised and is used by the Diff::LCS#sdiff
-  # method.
-  #
-  #     cbo = Diff::LCS::SDiffCallbacks.new
-  #     Diff::LCS.LCS(seq1, seq2, cbo)
-  #
-  # As with the other initialisable callback objects, Diff::LCS::SDiffCallbacks
-  # can be initialised with a block. As there is no "fininishing" to be done,
-  # this has no effect on the state of the object.
-  #
-  #     cbo = Diff::LCS::SDiffCallbacks.new { |tcbo| Diff::LCS.LCS(seq1, seq2, tcbo) }
-  #
-  # === Simplified Array Format
-  # The simplified array format used in the example above can be obtained
-  # with:
-  #
-  #     require 'pp'
-  #     pp diffs.map { |e| e.to_a }
-class Diff::LCS::SDiffCallbacks
-    # Returns the difference set collected during the diff process.
-  attr_reader :diffs
-
-  def initialize #:yields self:
-    @diffs = []
-    yield self if block_given?
-  end
-
-  def match(event)
-    @diffs << Diff::LCS::ContextChange.simplify(event)
-  end
-
-  def discard_a(event)
-    @diffs << Diff::LCS::ContextChange.simplify(event)
-  end
-
-  def discard_b(event)
-    @diffs << Diff::LCS::ContextChange.simplify(event)
-  end
-
-  def change(event)
-    @diffs << Diff::LCS::ContextChange.simplify(event)
-  end
-end

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

@@ -1,169 +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: change.rb,v 1.4 2004/08/08 20:33:09 austin Exp $
-#++
-# Provides Diff::LCS::Change and Diff::LCS::ContextChange.
-
-  # Centralises the change test code in Diff::LCS::Change and
-  # Diff::LCS::ContextChange, since it's the same for both classes.
-module Diff::LCS::ChangeTypeTests
-  def deleting?
-    @action == '-'
-  end
-
-  def adding?
-    @action == '+'
-  end
-
-  def unchanged?
-    @action == '='
-  end
-
-  def changed?
-    @changed == '!'
-  end
-
-  def finished_a?
-    @changed == '>'
-  end
-
-  def finished_b?
-    @changed == '<'
-  end
-end
-
-  # Represents a simplistic (non-contextual) change. Represents the removal or
-  # addition of an element from either the old or the new sequenced enumerable.
-class Diff::LCS::Change
-    # Returns the action this Change represents. Can be '+' (#adding?), '-'
-    # (#deleting?), '=' (#unchanged?), # or '!' (#changed?). When created by
-    # Diff::LCS#diff or Diff::LCS#sdiff, it may also be '>' (#finished_a?) or
-    # '<' (#finished_b?).
-  attr_reader :action
-  attr_reader :position
-  attr_reader :element
-
-  include Comparable
-  def ==(other)
-    (self.action == other.action) and
-    (self.position == other.position) and
-    (self.element == other.element)
-  end
-
-  def <=>(other)
-    r = self.action <=> other.action
-    r = self.position <=> other.position if r.zero?
-    r = self.element <=> other.element if r.zero?
-    r
-  end
-
-  def initialize(action, position, element)
-    @action = action
-    @position = position
-    @element = element
-  end
-
-    # Creates a Change from an array produced by Change#to_a.
-  def to_a
-    [@action, @position, @element]
-  end
-
-  def self.from_a(arr)
-    Diff::LCS::Change.new(arr[0], arr[1], arr[2])
-  end
-
-  include Diff::LCS::ChangeTypeTests
-end
-
-  # Represents a contextual change. Contains the position and values of the
-  # elements in the old and the new sequenced enumerables as well as the action
-  # taken.
-class Diff::LCS::ContextChange
-    # Returns the action this Change represents. Can be '+' (#adding?), '-'
-    # (#deleting?), '=' (#unchanged?), # or '!' (#changed?). When
-    # created by Diff::LCS#diff or Diff::LCS#sdiff, it may also be '>'
-    # (#finished_a?) or '<' (#finished_b?).
-  attr_reader :action
-  attr_reader :old_position
-  attr_reader :old_element
-  attr_reader :new_position
-  attr_reader :new_element
-
-  include Comparable
-
-  def ==(other)
-    (@action == other.action) and
-    (@old_position == other.old_position) and
-    (@new_position == other.new_position) and
-    (@old_element == other.old_element) and
-    (@new_element == other.new_element)
-  end
-
-  def inspect(*args)
-    %Q(#<#{self.class.name}:#{__id__} @action=#{action} positions=#{old_position},#{new_position} elements=#{old_element.inspect},#{new_element.inspect}>)
-  end
-
-  def <=>(other)
-    r = @action <=> other.action
-    r = @old_position <=> other.old_position if r.zero?
-    r = @new_position <=> other.new_position if r.zero?
-    r = @old_element <=> other.old_element if r.zero?
-    r = @new_element <=> other.new_element if r.zero?
-    r
-  end
-
-  def initialize(action, old_position, old_element, new_position, new_element)
-    @action = action
-    @old_position = old_position
-    @old_element = old_element
-    @new_position = new_position
-    @new_element = new_element
-  end
-
-  def to_a
-    [@action, [@old_position, @old_element], [@new_position, @new_element]]
-  end
-
-    # Creates a ContextChange from an array produced by ContextChange#to_a.
-  def self.from_a(arr)
-    if arr.size == 5
-      Diff::LCS::ContextChange.new(arr[0], arr[1], arr[2], arr[3], arr[4])
-    else
-      Diff::LCS::ContextChange.new(arr[0], arr[1][0], arr[1][1], arr[2][0],
-                                   arr[2][1])
-    end
-  end
-
-    # Simplifies a context change for use in some diff callbacks. '<' actions
-    # are converted to '-' and '>' actions are converted to '+'. 
-  def self.simplify(event)
-    ea = event.to_a
-
-    case ea[0]
-    when '-'
-      ea[2][1] = nil
-    when '<'
-      ea[0] = '-'
-      ea[2][1] = nil
-    when '+'
-      ea[1][1] = nil
-    when '>'
-      ea[0] = '+'
-      ea[1][1] = nil
-    end
-
-    Diff::LCS::ContextChange.from_a(ea)
-  end
-
-  include Diff::LCS::ChangeTypeTests
-end