messagebus_ruby_api 0.4.7 → 0.4.8

data/spec/ruby/1.9.1/gems/activesupport-3.0.9/lib/active_support/xml_mini/nokogiri.rb

@@ -1,83 +0,0 @@
-begin
-  require 'nokogiri'
-rescue LoadError => e
-  $stderr.puts "You don't have nokogiri installed in your application. Please add it to your Gemfile and run bundle install"
-  raise e
-end
-require 'active_support/core_ext/object/blank'
-
-# = XmlMini Nokogiri implementation
-module ActiveSupport
-  module XmlMini_Nokogiri #:nodoc:
-    extend self
-
-    # Parse an XML Document string or IO into a simple hash using libxml / nokogiri.
-    # data::
-    #   XML Document string or IO to parse
-    def parse(data)
-      if !data.respond_to?(:read)
-        data = StringIO.new(data || '')
-      end
-
-      char = data.getc
-      if char.nil?
-        {}
-      else
-        data.ungetc(char)
-        doc = Nokogiri::XML(data)
-        raise doc.errors.first if doc.errors.length > 0
-        doc.to_hash
-      end
-    end
-
-    module Conversions #:nodoc:
-      module Document #:nodoc:
-        def to_hash
-          root.to_hash
-        end
-      end
-
-      module Node #:nodoc:
-        CONTENT_ROOT = '__content__'.freeze
-
-        # Convert XML document to hash
-        #
-        # hash::
-        #   Hash to merge the converted element into.
-        def to_hash(hash={})
-          node_hash = {}
-
-          # Insert node hash into parent hash correctly.
-          case hash[name]
-            when Array then hash[name] << node_hash
-            when Hash  then hash[name] = [hash[name], node_hash]
-            when nil   then hash[name] = node_hash
-          end
-
-          # Handle child elements
-          children.each do |c|
-            if c.element?
-              c.to_hash(node_hash)
-            elsif c.text? || c.cdata?
-              node_hash[CONTENT_ROOT] ||= ''
-              node_hash[CONTENT_ROOT] << c.content
-            end
-          end
-
-          # Remove content node if it is blank and there are child tags
-          if node_hash.length > 1 && node_hash[CONTENT_ROOT].blank?
-            node_hash.delete(CONTENT_ROOT)
-          end
-
-          # Handle attributes
-          attribute_nodes.each { |a| node_hash[a.node_name] = a.value }
-
-          hash
-        end
-      end
-    end
-
-    Nokogiri::XML::Document.send(:include, Conversions::Document)
-    Nokogiri::XML::Node.send(:include, Conversions::Node)
-  end
-end

data/spec/ruby/1.9.1/gems/activesupport-3.0.9/lib/active_support/xml_mini/nokogirisax.rb

@@ -1,87 +0,0 @@
-begin
-  require 'nokogiri'
-rescue LoadError => e
-  $stderr.puts "You don't have nokogiri installed in your application. Please add it to your Gemfile and run bundle install"
-  raise e
-end
-require 'active_support/core_ext/object/blank'
-
-# = XmlMini Nokogiri implementation using a SAX-based parser
-module ActiveSupport
-  module XmlMini_NokogiriSAX
-    extend self
-
-    # Class that will build the hash while the XML document
-    # is being parsed using SAX events.
-    class HashBuilder < Nokogiri::XML::SAX::Document
-
-      CONTENT_KEY   = '__content__'.freeze
-      HASH_SIZE_KEY = '__hash_size__'.freeze
-
-      attr_reader :hash
-
-      def current_hash
-        @hash_stack.last
-      end
-
-      def start_document
-        @hash = {}
-        @hash_stack = [@hash]
-      end
-
-      def end_document
-        raise "Parse stack not empty!" if @hash_stack.size > 1
-      end
-
-      def error(error_message)
-        raise error_message
-      end
-
-      def start_element(name, attrs = [])
-        new_hash = { CONTENT_KEY => '' }.merge(Hash[attrs])
-        new_hash[HASH_SIZE_KEY] = new_hash.size + 1
-
-        case current_hash[name]
-          when Array then current_hash[name] << new_hash
-          when Hash  then current_hash[name] = [current_hash[name], new_hash]
-          when nil   then current_hash[name] = new_hash
-        end
-
-        @hash_stack.push(new_hash)
-      end
-
-      def end_element(name)
-        if current_hash.length > current_hash.delete(HASH_SIZE_KEY) && current_hash[CONTENT_KEY].blank? || current_hash[CONTENT_KEY] == ''
-          current_hash.delete(CONTENT_KEY)
-        end
-        @hash_stack.pop
-      end
-
-      def characters(string)
-        current_hash[CONTENT_KEY] << string
-      end
-
-      alias_method :cdata_block, :characters
-    end
-
-    attr_accessor :document_class
-    self.document_class = HashBuilder
-
-    def parse(data)
-      if !data.respond_to?(:read)
-        data = StringIO.new(data || '')
-      end
-
-      char = data.getc
-      if char.nil?
-        {}
-      else
-        data.ungetc(char)
-        document = self.document_class.new
-        parser = Nokogiri::XML::SAX::Parser.new(document)
-        parser.parse(data)
-        document.hash
-      end
-    end
-  end
-end

data/spec/ruby/1.9.1/gems/activesupport-3.0.9/lib/active_support/xml_mini/rexml.rb

@@ -1,129 +0,0 @@
-require 'active_support/core_ext/kernel/reporting'
-require 'active_support/core_ext/object/blank'
-
-# = XmlMini ReXML implementation
-module ActiveSupport
-  module XmlMini_REXML #:nodoc:
-    extend self
-
-    CONTENT_KEY = '__content__'.freeze
-
-    # Parse an XML Document string or IO into a simple hash
-    #
-    # Same as XmlSimple::xml_in but doesn't shoot itself in the foot,
-    # and uses the defaults from Active Support.
-    #
-    # data::
-    #   XML Document string or IO to parse
-    def parse(data)
-      if !data.respond_to?(:read)
-        data = StringIO.new(data || '')
-      end
-
-      char = data.getc
-      if char.nil?
-        {}
-      else
-        data.ungetc(char)
-        silence_warnings { require 'rexml/document' } unless defined?(REXML::Document)
-        doc = REXML::Document.new(data)
-
-        if doc.root
-          merge_element!({}, doc.root)
-        else
-          raise REXML::ParseException,
-            "The document #{doc.to_s.inspect} does not have a valid root"
-        end
-      end
-    end
-
-    private
-      # Convert an XML element and merge into the hash
-      #
-      # hash::
-      #   Hash to merge the converted element into.
-      # element::
-      #   XML element to merge into hash
-      def merge_element!(hash, element)
-        merge!(hash, element.name, collapse(element))
-      end
-
-      # Actually converts an XML document element into a data structure.
-      #
-      # element::
-      #   The document element to be collapsed.
-      def collapse(element)
-        hash = get_attributes(element)
-
-        if element.has_elements?
-          element.each_element {|child| merge_element!(hash, child) }
-          merge_texts!(hash, element) unless empty_content?(element)
-          hash
-        else
-          merge_texts!(hash, element)
-        end
-      end
-
-      # Merge all the texts of an element into the hash
-      #
-      # hash::
-      #   Hash to add the converted element to.
-      # element::
-      #   XML element whose texts are to me merged into the hash
-      def merge_texts!(hash, element)
-        unless element.has_text?
-          hash
-        else
-          # must use value to prevent double-escaping
-          texts = ''
-          element.texts.each { |t| texts << t.value }
-          merge!(hash, CONTENT_KEY, texts)
-        end
-      end
-
-      # Adds a new key/value pair to an existing Hash. If the key to be added
-      # already exists and the existing value associated with key is not
-      # an Array, it will be wrapped in an Array. Then the new value is
-      # appended to that Array.
-      #
-      # hash::
-      #   Hash to add key/value pair to.
-      # key::
-      #   Key to be added.
-      # value::
-      #   Value to be associated with key.
-      def merge!(hash, key, value)
-        if hash.has_key?(key)
-          if hash[key].instance_of?(Array)
-            hash[key] << value
-          else
-            hash[key] = [hash[key], value]
-          end
-        elsif value.instance_of?(Array)
-          hash[key] = [value]
-        else
-          hash[key] = value
-        end
-        hash
-      end
-
-      # Converts the attributes array of an XML element into a hash.
-      # Returns an empty Hash if node has no attributes.
-      #
-      # element::
-      #   XML element to extract attributes from.
-      def get_attributes(element)
-        attributes = {}
-        element.attributes.each { |n,v| attributes[n] = v }
-        attributes
-      end
-
-      # Determines if a document element has text content
-      #
-      # element::
-      #   XML element to be checked.
-      def empty_content?(element)
-        element.texts.join.blank?
-      end
-  end
-end

data/spec/ruby/1.9.1/gems/diff-lcs-1.1.2/ChangeLog

@@ -1,46 +0,0 @@
-Revision history for Ruby library Diff::LCS. Unless explicitly noted otherwise,
-all changes are produced by Austin Ziegler <diff-lcs@halostatue.ca>.
-
-== Diff::LCS 1.1.2
-* Fixed a problem reported by Mauricio Fernandez in htmldiff. Future versions
-  of Diff::LCS will be removing this program.
-
-== Diff::LCS 1.1.1
-* Fixed bug #891:
-  http://rubyforge.org/tracker/?func=detail&atid=407&aid=891&group_id=84
-* Fixed a problem with callback initialisation code (it assumed that all
-  callbacks passed as classes can be initialised; now, it rescues
-  NoMethodError in the event of private :new being called).
-* Modified the non-initialisable callbacks to have a private #new method.
-* Moved ldiff core code to Diff::LCS::Ldiff (diff/lcs/ldiff.rb).
-
-== Diff::LCS 1.1.0
-* Eliminated the need for Diff::LCS::Event and removed it.
-* Added a contextual diff callback, Diff::LCS::ContextDiffCallback.
-* Implemented patching/unpatching for standard Diff callback output formats
-  with both #diff and #sdiff.
-* Extensive documentation changes.
-
-== Diff::LCS 1.0.4
-* Fixed a problem with bin/ldiff output, especially for unified format.
-  Newlines that should have been present weren't.
-* Changed the .tar.gz installer to generate Windows batch files if ones do not
-  exist already. Removed the existing batch files as they didn't work.
-
-== Diff::LCS 1.0.3
-* Fixed a problem with #traverse_sequences where the first difference from the
-  left sequence might not be appropriately captured.
-
-== Diff::LCS 1.0.2
-* Fixed an issue with ldiff not working because actions were changed from
-  symbols to strings.
-
-== Diff::LCS 1.0.1
-* Minor modifications to the gemspec, the README.
-* Renamed the diff program to ldiff (as well as the companion batch file) so as
-  to not collide with the standard diff program.
-* Fixed issues with RubyGEMs. Requires RubyGems > 0.6.1 or >= 0.6.1 with the
-  latest CVS version.
-
-== Diff::LCS 1.0
-* Initial release based mostly on Perl's Algorithm::Diff.

data/spec/ruby/1.9.1/gems/diff-lcs-1.1.2/Install

@@ -1,6 +0,0 @@
-Installing this package is as simple as:
-
-% ruby install.rb
-
-Alternatively, you can use the RubyGem version of Diff::LCS available as
-diff-lcs-1.1.2.gem from the usual sources.

data/spec/ruby/1.9.1/gems/diff-lcs-1.1.2/README

@@ -1,76 +0,0 @@
-Diff::LCS README
-================
-Diff::LCS is a port of Algorithm::Diff[1] that uses the McIlroy-Hunt
-longest common subsequence (LCS) algorithm to compute intelligent
-differences between two sequenced enumerable containers[2]. The
-implementation is based on Mario I. Wolczko's[3] Smalltalk version (1.2,
-1993)[4] and Ned Konz's[5] Perl version (Algorithm::Diff)[6].
-
-This release is version 1.1.2, fixing an htmldiff bug in 1.1.1. Version 1.1.0
-added new features, including the ability to #patch and #unpatch changes as
-well as a new contextual diff callback, Diff::LCS::ContextDiffCallbacks, that
-should improve the context sensitivity of patching.
-
-Using this module is quite simple. By default, Diff::LCS does not extend
-objects with the Diff::LCS interface, but will be called as if it were a
-function:
-
-  require 'diff/lcs'
-
-  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)
-
-  lcs = Diff::LCS.LCS(seq1, seq2)
-  diffs = Diff::LCS.diff(seq1, seq2)
-  sdiff = Diff::LCS.sdiff(seq1, seq2)
-  seq = Diff::LCS.traverse_sequences(seq1, seq2, callback_obj)
-  bal = Diff::LCS.traverse_balanced(seq1, seq2, callback_obj)
-  seq2 == Diff::LCS.patch!(seq1, diffs)
-  seq1 == Diff::LCS.unpatch!(seq2, diffs)
-  seq2 == Diff::LCS.patch!(seq1, sdiff)
-  seq1 == Diff::LCS.unpatch!(seq2, sdiff)
-
-Objects can be extended with Diff::LCS:
-
-  seq1.extend(Diff::LCS)
-  lcs = seq1.lcs(seq2)
-  diffs = seq1.diff(seq2)
-  sdiff = seq1.sdiff(seq2)
-  seq = seq1.traverse_sequences(seq2, callback_obj)
-  bal = seq1.traverse_balanced(seq2, callback_obj)
-  seq2 == seq1.patch!(diffs)
-  seq1 == seq2.unpatch!(diffs)
-  seq2 == seq1.patch!(sdiff)
-  seq1 == seq2.unpatch!(sdiff)
-
-By requiring 'diff/lcs/array' or 'diff/lcs/string', Array or String will
-be extended for use this way.
-
-Copyright
-=========
-# 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: README,v 1.7 2004/10/17 20:31:10 austin Exp $
-
-Footnotes
-=========
-[1] This library is called Diff::LCS because there are multiple
-    Ruby libraries called Algorithm::Diff maintained by other authors.
-[2] By sequenced enumerable, I mean that the order of enumeration is
-    predictable and consistent for the same set of data. While it is
-    theoretically possible to generate a diff for unordereded hash, it
-    will only be meaningful if the enumeration of the hashes is
-    consistent. In general, this will mean that containers that behave
-    like String or Array will perform best.
-[3] mario@wolczko.com
-[4] ftp://st.cs.uiuc.edu/pub/Smalltalk/MANCHESTER/manchester/4.0/diff.st
-[5] perl@bike-nomad.com
-[6] http://search.cpan.org/~nedkonz/Algorithm-Diff-1.15/

data/spec/ruby/1.9.1/gems/diff-lcs-1.1.2/Rakefile

@@ -1,116 +0,0 @@
-#! /usr/bin/env rake
-$LOAD_PATH.unshift('lib')
-
-require 'rubygems'
-require 'rake/gempackagetask'
-require 'rake/contrib/rubyforgepublisher'
-require 'diff/lcs'
-require 'archive/tar/minitar'
-require 'zlib'
-
-DISTDIR = "diff-lcs-#{Diff::LCS::VERSION}"
-TARDIST = "../#{DISTDIR}.tar.gz"
-
-DATE_RE = %r<(\d{4})[./-]?(\d{2})[./-]?(\d{2})(?:[\sT]?(\d{2})[:.]?(\d{2})[:.]?(\d{2})?)?>
-
-if ENV['RELEASE_DATE']
-  year, month, day, hour, minute, second = DATE_RE.match(ENV['RELEASE_DATE']).captures
-  year ||= 0
-  month ||= 0
-  day ||= 0
-  hour ||= 0
-  minute ||= 0
-  second ||= 0
-  ReleaseDate = Time.mktime(year, month, day, hour, minute, second)
-else
-  ReleaseDate = nil
-end
-
-task :test do |t|
-  require 'test/unit/testsuite'
-  require 'test/unit/ui/console/testrunner'
-
-  runner = Test::Unit::UI::Console::TestRunner
-
-  $LOAD_PATH.unshift('tests')
-  $stderr.puts "Checking for test cases:" if t.verbose
-  Dir['tests/*test*.rb'].each do |testcase|
-    $stderr.puts "\t#{testcase}" if t.verbose
-    load testcase
-  end
-
-  suite = Test::Unit::TestSuite.new
-
-  ObjectSpace.each_object(Class) do |testcase|
-    suite << testcase.suite if testcase < Test::Unit::TestCase
-  end
-
-  runner.run(suite)
-end
-
-spec = eval(File.read("diff-lcs.gemspec"))
-desc "Build the RubyGem for Diff::LCS."
-task :gem => [ :test ]
-Rake::GemPackageTask.new(spec) do |g|
-  g.need_tar    = false
-  g.need_zip    = false
-  g.package_dir = ".."
-end
-
-desc "Build an Diff::LCS .tar.gz distribution."
-task :tar => [ TARDIST ]
-file TARDIST => [ :test ] do |t|
-  current = File.basename(Dir.pwd)
-  Dir.chdir("..") do
-    begin
-      files = Dir["#{current}/**/*"].select { |dd| dd !~ %r{(?:/CVS/?|~$)} }
-      files.map! do |dd|
-        ddnew = dd.gsub(/^#{current}/, DISTDIR)
-        mtime = ReleaseDate || File.stat(dd).mtime
-        if File.directory?(dd)
-          { :name => ddnew, :mode => 0755, :dir => true, :mtime => mtime }
-        else
-          if dd =~ %r{bin/}
-            mode = 0755
-          else
-            mode = 0644
-          end
-          data = File.read(dd)
-          { :name => ddnew, :mode => mode, :data => data, :size => data.size,
-            :mtime => mtime }
-        end
-      end
-
-      ff = File.open(t.name.gsub(%r{^\.\./}o, ''), "wb")
-      gz = Zlib::GzipWriter.new(ff)
-      tw = Archive::Tar::Minitar::Writer.new(gz)
-
-      files.each do |entry|
-        if entry[:dir]
-          tw.mkdir(entry[:name], entry)
-        else
-          tw.add_file_simple(entry[:name], entry) { |os| os.write(entry[:data]) }
-        end
-      end
-    ensure
-      tw.close if tw
-      gz.close if gz
-    end
-  end
-end
-task TARDIST => [ :test ]
-
-def sign(file)
-  sh %("C:\\Program Files\\Windows Privacy Tools\\GnuPG\\Gpg.exe" -ba #{file}) rescue nil
-end
-
-task :signtar => [ :tar ] do
-  sign TARDIST
-end
-task :signgem => [ :gem ] do
-  sign "../#{DISTDIR}.gem"
-end
-
-desc "Build everything."
-task :default => [ :signtar, :signgem ] do
-end