conflict 0.1.0

data/lib/conflict/domain.rb

@@ -0,0 +1,89 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module Conflict
+
+class Conflict
+  
+  attr_reader :local, :remote
+
+  def initialize local, remote
+    raise ConflictException::new("local event cannot be nil") if nil.eql?(local)
+    raise ConflictException::new("remote event cannot be nil") if nil.eql?(remote)
+    raise ConflictException::new("local resource '" + local.resource + "' does not match remote resource '" + remote.resource + "'") if ! local.resource.eql?(remote.resource)
+    raise ConflictException::new("local and remote cannot have the same identity") if local == remote
+    #what about = names, not = resources?
+    raise ConflictException::new("local and remote cannot be eql") if local.eql?(remote)
+    # using clone because jvYaml does not currently support aliasing
+    @local, @remote = local.clone, remote.clone
+  end
+  
+  def eql? other
+    @local.eql?(other.local) and @remote.eql?(other.remote)
+  end
+  
+  yaml_as "tag:java.yaml.org,2002:object:com.thoughtworks.conflict.Conflict"
+  
+end
+
+class Event
+
+  attr_reader :client, :action, :resource
+  
+  # should at least make constants for event types ?
+  def initialize client, action, resource, created=Time.now, ttl=TTL
+    
+    raise ConflictException::new("invalid action '" + action.to_s + "'") if ! ['added', 'changed', 'deleted'].index(action)
+    raise ConflictException::new("client must not be empty value") if nil.eql?(client) or client.empty?
+    raise ConflictException::new("resource must not be empty value") if nil.eql?(resource) or resource.empty?
+    raise ConflictException::new("ttl cannot be negative") if ttl < 0
+    @client, @action, @resource = client, action, resource
+    # kept around for staleness expiration
+    @created_time = created
+    # rendered in YAML
+    @created = [created.year, created.month, created.day, created.hour, created.min] * "-"
+    @ttl = ttl
+  end
+
+  def eql? other
+    @client.eql?(other.client) and @action.eql?(other.action) and @resource.eql?(other.resource)
+  end
+
+  def to_s
+    self.class.to_s + ":" + @client.to_s + " " + @action.to_s + " " + resource.to_s 
+  end
+  
+  def to_yaml_properties
+    fields = self.instance_variables.clone
+    fields.delete "@created_time" # keep data/time out of integration point ( ruby != java != .net )
+    fields.delete "@ttl"
+    fields
+  end
+
+  yaml_as "tag:java.yaml.org,2002:object:com.thoughtworks.conflict.Event"
+
+  def to_xml
+    '<event client="' + self.client + '" action="' + self.action + '" resource="' + self.resource + '" />'
+  end
+
+  def expires
+    @created_time + @ttl
+  end
+  
+end
+
+end

data/lib/conflict/parsers.rb

@@ -0,0 +1,130 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module Conflict
+
+class RequestParser
+
+  def initialize ttl
+    raise ConflictException::new("ttl cannot be nil") if nil.eql?(ttl)
+    raise ConflictException::new("ttl cannot be negative") if ttl < 0
+    @ttl = ttl
+  end
+
+  def parse diff, info, client
+    
+    events = []
+
+    for i in 0..diff.list.size - 1
+        
+      diff_data = diff.list[i].to_s.strip
+      info_data = info.list[i].to_s.strip
+        
+      raise "no value for info @ index " + i.to_s if nil.eql?(info_data) or info_data.empty?
+      
+      lambda {
+        infos = InfoParser::new().parse(info_data)
+        events = events | DiffParser::new(infos.merge({:ttl=>@ttl})).parse(diff_data, client)
+      }.call if ! nil.eql?(diff_data) && ! diff_data.empty?
+      
+    end
+    
+    events
+    
+  end
+  
+end
+
+class InfoParser
+  
+  @@url, @@path = "URL: ", "Path: "
+  
+  def parse info
+  
+    raise ConflictException::new("info cannot be nil or empty") if nil.eql?(info) || info.empty?
+  
+    properties = {}
+    
+    info.split(%r{\n}).each do | line |
+      properties[:url] = line.to_s.sub(@@url, "").chomp if line.to_s.index(@@url) == 0
+      properties[:path] = line.to_s.sub(@@path, "").chomp if line.to_s.index(@@path) == 0
+    end
+    
+    properties
+  end
+  
+end
+
+class DiffParser
+  
+  @@key = "Index: "
+  
+  def initialize cfg
+    raise ConflictException::new("cfg cannot be nil") if nil.eql?(cfg)
+    raise ConflictException::new("url value cannot be nil or empty") if nil.eql?(cfg[:url]) or cfg[:url].empty?
+    raise ConflictException::new("path value cannot be nil or empty") if nil.eql?(cfg[:path]) or cfg[:path].empty?
+    raise ConflictException::new("ttl value cannot be nil") if nil.eql?(cfg[:ttl])
+    raise ConflictException::new("ttl cannot be negative") if cfg[:ttl] < 0
+    @cfg = cfg
+  end
+  
+  def parse diff, client # would be nice to just get a 3rd party for this
+  
+    raise ConflictException::new("client cannot by empty") if nil.eql?(client) || client.empty?
+    raise ConflictException::new("diff cannot by empty") if nil.eql?(diff) || diff.empty?
+    events = []
+    resource = ""
+    lines = diff.split(%r{\n})
+    #Conflict.logger.info("received diff w/ " + lines.size.to_s + " line(s)")
+    bit = true
+    now = Time.now # use one var, so all events for a request get same creation time
+    lines.each do |line|
+      if bit
+        if line.to_s.index(@@key) == 0
+          resource = line.to_s.sub(@@key, "") 
+          bit = ! bit
+        end
+      else
+        if line.to_s.index("@@ ") == 0
+          action = infer_action line
+          resource_full = infer_resource(@cfg[:url].to_s, @cfg[:path], resource)
+          events << Event::new(client, action, resource_full, now, @cfg[:ttl])
+          bit = ! bit
+        end
+      end
+    end
+    
+    events
+  end
+  
+  private
+  def infer_action numbers # we are assuming a lot about unified diff here
+    tokens = numbers.split(' ')
+    # had to go backwards for the last three in delete, webrick or the clients are 
+    # dropping the '+' character
+    tokens[2][-3,tokens[2].length].eql?("0,0") ? "deleted" : tokens[1].eql?("-0,0") ? "added" : "changed"
+  end
+  
+  def infer_resource url, path, resource
+    path = path.tr("\\", "/").chomp
+    resource = resource.tr("\\", "/").chomp
+    url.chomp + ( ".".eql?(path) ? "/" + resource : resource.sub(path, ""))
+  end
+
+end
+  
+end

data/lib/run_conflict

@@ -0,0 +1,26 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+#!/usr/bin/env ruby
+require 'conflict'
+
+port = ARGV.index('-port') ? ARGV[ARGV.index('-port') + 1] : nil
+ttl = ARGV.index('-ttl') ? ARGV[ARGV.index('-ttl') + 1] : nil
+
+s = Conflict::Server::new({:port=>port, :ttl=>ttl})
+trap("INT"){ s.stop }
+s.start

data/test/common.rb

@@ -0,0 +1,132 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+require 'test/unit'
+require 'net/http'
+module Conflict
+
+class DataBase
+  def presence_of item
+    @db.index(item)
+  end
+  def insert item
+    @db << item
+  end
+end
+
+class Client
+  
+  def initialize cfg={}
+    @cfg = {}
+    @cfg[:command] = cfg[:command] ||= "svn diff"
+    @cfg[:id] = cfg[:id] ||= "Conflict Ruby client"
+    @cfg[:ip] = cfg[:ip] ||= "127.0.0.1"
+    @cfg[:port] = cfg[:port] ||= PORT
+    @cfg[:poll] = cfg[:poll] ||= 3
+  end
+  
+  def resend
+    raise ConflictException::new('do not call resend before calling send') if ! defined?(@last_diff) or ! defined?(@last_info)
+    diff @last_diff, @last_info
+  end
+  
+  def diff diff, info
+  
+    raise ConflictException::new('info cannot be nil or empty') if nil.eql?(info) || info.empty?
+    
+    response = multi_diff [diff], [info]  # a multi diff of one
+    @last_diff, @last_info = diff, info
+    response
+  end
+  
+  def multi_diff diff, info
+    body = {"client" => @cfg[:id]}
+    diff.each do | d | body = body.merge("diff"=>d, "path"=>".") end
+    info.each do | i | body = body.merge("info"=>i) end
+    YAML.load send(DIFF_URL, body)
+  end
+  
+  def revert info
+    diff("", info)
+  end
+  
+  #make this static?
+  def count
+    body = send(STATUS_URL, {})
+    document = REXML::Document.new(body)
+    document.root.elements['events'].size
+  end
+  
+  def poll
+    
+    while true
+      diff = `#{@cfg[:command]}`
+      info = `svn info`
+      puts multi_diff([diff], [info]).to_yaml
+      sleep @cfg[:poll]
+    end
+    
+  end
+
+  def to_s
+    self.class.to_s + " " + @cfg.to_s
+  end
+
+  private
+  def send url, body
+    req = Net::HTTP::Post.new(url)
+    req.set_form_data(body)
+    http = Net::HTTP.new(@cfg[:ip],@cfg[:port])
+    res = http.request(req)
+    res.body
+  end
+  
+end  
+  
+end
+
+module ConflictConstants
+
+  CLIENT_ONE = "unit test"
+  CLIENT_TWO = "unit test 2"
+  CLIENT_THREE = "unit test 3"
+  NO_CONFLICT = [].to_yaml
+  CONTROLLER = "com.thoughtworks.Controller.java"
+  VIEW = "com.thoughtworks.View.java"
+  MODEL = "com.thoughtworks.Model.java"  
+  DATA_DIR = './test/data/'
+  STOMP_DIR = DATA_DIR + 'stomp/'  
+  STOMP_1_INFO_PATH = STOMP_DIR + 'stomp.1.info.txt'
+  STOMP_2_INFO_PATH = STOMP_DIR + 'stomp.2.info.txt'
+  STOMP_1_DIFF_PATH = STOMP_DIR + 'stomp.1.diff.txt'
+  STOMP_2_DIFF_PATH = STOMP_DIR + 'stomp.2.diff.txt'  
+  STOMP_1_URL = 'http://svn.codehaus.org/stomp/ruby/trunk'
+  STOMP_2_URL = 'http://svn.codehaus.org/stomp/ruby/trunk/lib'  
+  STOMP_RESOURCE = STOMP_2_URL + "/stomp.rb"
+  CONFLICT_URL = 'https://conflict.svn.sourceforge.net/svnroot/conflict/src/ruby'
+  
+end
+  
+class File
+  def to_s
+    string = ""
+    self.each do | line | string += line.to_s end
+    self.close
+    string
+  end
+end  
+

data/test/data/a13g.diff.txt

@@ -0,0 +1,379 @@
+Index: asqs.rb
+===================================================================
+--- asqs.rb	(revision 107)
++++ asqs.rb	(working copy)
+@@ -1,354 +0,0 @@
+-module ActiveMessaging
+-  module Adapters
+-    module AmazonSQS
+-
+-      class Connection
+-        include ActiveMessaging::Adapter
+-
+-        register :asqs
+-
+-        QUEUE_NAME = 1..80
+-        MESSAGE_SIZE = 1..(256 * 1024)
+-        VISIBILITY_TIMEOUT = 0..(24 * 60 * 60)
+-        NUMBER_OF_MESSAGES = 1..255
+-
+-        #configurable params
+-        attr_accessor :reliable, :reconnectDelay, :access_key_id, :secret_access_key, :aws_version, :content_type, :host, :port, :poll_interval, :cache_queue_list
+-        
+-        #generic init method needed by a13g
+-        def initialize cfg
+-            raise "Must specify a access_key_id" if (cfg[:access_key_id].nil? || cfg[:access_key_id].empty?)
+-            raise "Must specify a secret_access_key" if (cfg[:secret_access_key].nil? || cfg[:secret_access_key].empty?)
+-
+-            @access_key_id=cfg[:access_key_id]
+-            @secret_access_key=cfg[:secret_access_key]
+-            @aws_version = cfg[:aws_version]            || '2006-04-01' 
+-            @content_type = cfg[:content_type]          || 'text/plain'
+-            @host = cfg[:host]                          || 'queue.amazonaws.com'
+-            @port = cfg[:port]                          || 80
+-            @poll_interval = cfg[:poll_interval]        || 1
+-            @cache_queue_list = cfg[:cache_queue_list]  || true
+-            @reliable = cfg[:reliable]                  ||= true
+-            @reconnectDelay = cfg[:reconnectDelay]      ||= 5
+-            
+-            #initialize the subscriptions and queues
+-            @subscriptions = {}
+-            @current_subscription = 0
+-            queues
+-        end
+-
+-        def disconnect
+-          #it's an http request - there is no disconnect - ha!
+-        end
+-
+-        # queue_name string, headers hash
+-        # for sqs, make sure queue exists, if not create, then add to list of polled queues
+-        def subscribe queue_name, message_headers={}
+-          # look at the existing queues, create any that are missing
+-          queue = get_or_create_queue queue_name
+-          if @subscriptions.has_key? queue.name
+-            @subscriptions[queue.name] += 1
+-          else
+-            @subscriptions[queue.name] = 1 
+-          end
+-        end
+-
+-        # queue_name string, headers hash
+-        # for sqs, attempt delete the queues, won't work if not empty, that's ok
+-        def unsubscribe queue_name, message_headers={}
+-          @subscriptions[queue_name] -= 1
+-          @subscriptions.delete(queue_name) if @subscriptions[queue_name] <= 0
+-        end
+-
+-        # queue_name string, body string, headers hash
+-        # send a single message to a queue
+-        def send queue_name, message_body, message_headers
+-          queue = get_or_create_queue queue_name
+-          send_messsage queue, message_body
+-        end
+-
+-        # receive a single message from any of the subscribed queues
+-        # check each queue once, then sleep for poll_interval
+-        def receive
+-          raise "No subscriptions to receive messages from." if (@subscriptions.nil? || @subscriptions.empty?)
+-          start = @current_subscription
+-          while true
+-            @current_subscription = ((@current_subscription < @subscriptions.length-1) ? @current_subscription + 1 : 0)
+-            sleep poll_interval if (@current_subscription == start)
+-            queue_name = @subscriptions.keys.sort[@current_subscription]
+-            queue = queues[queue_name]
+-            unless queue.nil?
+-              messages = retrieve_messsages queue, 1
+-              return messages[0] unless (messages.nil? or messages.empty?)
+-            end
+-          end
+-        end
+-
+-        def received message
+-          delete_message message
+-        end
+-        
+-        protected
+-        
+-        #belows are the methods from the REST API
+-        def create_queue queue_name
+-          validate_queue_name queue_name
+-          validate_queue queue_name, false
+-          response = transmit 'POST', "/?QueueName=#{queue_name}"
+-          add_queue response.get_text("//QueueUrl")
+-        end
+-
+-        def list_queues queue_name_prefix=nil
+-          validate_queue_name queue_name_prefix unless queue_name_prefix.nil?
+-          response = transmit 'GET', queue_name_prefix.nil? ? '/' : "/?QueueNamePrefix=#{queue_name_prefix}"
+-          response.nodes("//QueueUrl").collect{ |n| add_queue(n.text) }
+-        end
+-        
+-        def delete_queue queue
+-          validate_queue queue
+-          response = transmit 'DELETE', "#{queue.queue_url}", queue.domain
+-        end
+-        
+-        def send_messsage queue, message
+-          validate_queue queue
+-          validate_message message
+-          response = transmit 'PUT', "#{queue.queue_url}/back", queue.domain, message
+-        end
+-        
+-        def set_visibility_timeout queue, timeout
+-          validate_queue queue
+-          validate_timeout timeout
+-          response = transmit 'PUT', "#{queue.queue_url}?VisibilityTimeout=#{timeout}", queue.domain
+-        end
+-
+-        def retrieve_messsages queue, num_messages=1, timeout=nil
+-          validate_queue queue
+-          validate_number_of_messages num_messages
+-          validate_timeout timeout if timeout
+-          timeout_path = timeout ? "VisibilityTimeout=#{timeout}&" : ''
+-          response = transmit 'GET', "#{queue.queue_url}/front?#{timeout_path}NumberOfMessages=#{num_messages}", queue.domain
+-          response.nodes("//Message").collect{ |n| Message.from_element n, response, queue }
+-        end
+-        
+-        def get_visibility_timeout queue
+-          validate_queue queue
+-          response = transmit 'GET', "#{queue.queue_url}/", queue.domain
+-          response.get_text('//VisibilityTimeout').to_i
+-        end
+-        
+-        def delete_message message
+-          delete_message_by_id message.queue, message.id
+-        end
+-
+-        def delete_message_by_id queue, message_id
+-          response = transmit 'DELETE', "#{queue.queue_url}/#{message_id}", queue.domain
+-        end
+-
+-        def peek_message queue, message_id
+-          response = transmit 'GET', "#{queue.queue_url}/#{message_id}", queue.domain
+-          Message.from_element( response.node('//Message'), response, queue)
+-        end
+-        
+-        private
+-        
+-        def queues
+-          return @queues if (@queues && cache_queue_list)
+-          @queues = {}
+-          list_queues.each{|q| @queues[q.name]=q }
+-          return @queues
+-        end
+-
+-        def get_or_create_queue queue_name
+-          qs = queues
+-          qs.has_key?(queue_name) ? qs[queue_name] : create_queue(queue_name)
+-        end
+-        
+-        def add_queue(url)
+-          q = Queue.from_url url
+-          queues[q.name] = q if cache_queue_list
+-          return q
+-        end
+-
+-        # method to do the actual send, generic to get, post, delete, etc.
+-        # action - possible values: get, post, delete
+-        def transmit(command, url, h=host, body=nil, headers={}, p=port)
+-          request_headers = create_headers(command, url, headers, body)
+-          request = http_request_factory(command, url, request_headers, body)
+-          tryit = true
+-          begin
+-            while tryit
+-              response = SQSResponse.new(Net::HTTP.start(h, p){ |http| http.request(request) })
+-              tryit = false
+-            end
+-          rescue
+-            raise $! unless reliable
+-            puts "transmit failed, will retry in #{@reconnectDelay} seconds"
+-            sleep @reconnectDelay
+-          end
+-          # p response
+-          # puts "body: #{response.http_response.body}"
+-          check_errors(response)
+-        end
+-        
+-        def create_headers(cmd, url, headers, body)
+-          # set then merge the headers
+-          hdrs = { 'AWS-Version'=>@aws_version, 
+-                   'Date'=>Time.now.httpdate, 
+-                   'Content-type'=>@content_type }
+-          hdrs['Content-Length'] = body.length.to_s if (body && (cmd=='POST' or cmd=='PUT'))
+-          
+-
+-          #merge with the passed in headers to allow overrides
+-          hdrs.merge! headers
+-          
+-          # calculate authorization based on set headers
+-          hdrs['Authorization'] = create_authorization_signature(cmd, url, hdrs)
+-          return hdrs
+-        end
+-
+-        def create_authorization_signature(cmd, url, hdrs)
+-          base_url = url.index('?') ? url[0..(url.index('?')-1)] : url
+-          to_sign = "#{cmd}\n\n#{hdrs['Content-type']}\n#{hdrs['Date']}\n#{base_url}"
+-          # puts to_sign
+-          signature = Base64.encode64(OpenSSL::HMAC.digest(OpenSSL::Digest::Digest.new('sha1'), secret_access_key, to_sign)).strip
+-          return "AWS #{access_key_id}:#{signature}"
+-        end
+-
+-        def http_request_factory(cmd, url, headers, body)
+-          case cmd
+-          when 'GET' then Net::HTTP::Get.new(url,headers)
+-          when 'DELETE' then Net::HTTP::Delete.new(url,headers)
+-          when 'POST'
+-              req = Net::HTTP::Post.new(url,headers)
+-              req.body=body
+-              req
+-          when 'PUT'
+-              req = Net::HTTP::Put.new(url,headers)
+-              req.body=body
+-              req
+-          else raise 'Unsupported http request type'
+-          end
+-        end
+-
+-        def check_errors(response)
+-          raise response.errors if response.errors?
+-          response
+-        end
+-        
+-        def validate_queue_name qn
+-          raise "Queue name, #{qn}, must be between #{QUEUE_NAME.min} and #{QUEUE_NAME.max} characters." unless QUEUE_NAME.include?(qn.length)
+-          raise "Queue name, #{qn}, must be alphanumeric only." if (qn =~ /\W/ )
+-        end
+-
+-        def validate_queue qn, exists=true
+-          if exists
+-            raise "Never heard of queue, can't use it: #{qn.name}" unless queues.has_key? qn.name
+-          else
+-            raise "Queue already exists: #{qn}" if queues.has_key? qn.name
+-          end
+-        end
+-
+-        def validate_message m
+-          raise "Message cannot be nil." if m.nil?
+-          raise "Message length, #{m.length}, must be between #{MESSAGE_SIZE.min} and #{MESSAGE_SIZE.max}." unless MESSAGE_SIZE.include?(m.length)
+-        end
+-
+-        def validate_timeout to
+-          raise "Timeout, #{to}, must be between #{VISIBILITY_TIMEOUT.min} and #{VISIBILITY_TIMEOUT.max}." unless VISIBILITY_TIMEOUT.include?(to)
+-        end
+-
+-        def validate_number_of_messages nom
+-          raise "Number of messages, #{nom}, must be between #{NUMBER_OF_MESSAGES.min} and #{NUMBER_OF_MESSAGES.max}." unless NUMBER_OF_MESSAGES.include?(nom)
+-        end
+-
+-      end
+-
+-      class SQSResponse
+-        attr_accessor :headers, :doc, :http_response
+-        
+-        def initialize response
+-          @http_response = response
+-          @headers = response.to_hash()
+-          @doc = REXML::Document.new(response.body) if response.kind_of?(Net::HTTPSuccess)
+-        end
+-      
+-        def message_type
+-          return doc ? doc.root.name : ''
+-        end
+-
+-        def errors?
+-          (not http_response.kind_of?(Net::HTTPSuccess)) or (message_type == "Response")
+-        end
+-
+-        def errors
+-          msg = ""
+-          if  http_response.kind_of?(Net::HTTPSuccess)
+-            msg = "Errors: "
+-            each_node('/Response/Errors/Error') { |n|
+-              c = n.elements['Code'].text
+-              m = n.elements['Message'].text
+-              msg << ", " if msg != "Errors: "
+-              msg << "#{c} : #{m}"
+-            }
+-          else
+-            msg = "HTTP Error: #{http_response.code} : #{http_response.message}"
+-          end
+-          return msg
+-        end
+-      
+-        def get_text(xpath,default='')
+-          e = REXML::XPath.first( doc, xpath)
+-          e.nil? ? default : e.text
+-        end
+-      
+-        def each_node(xp)
+-          REXML::XPath.each(doc.root, xp) {|n| yield n}
+-        end
+-      
+-        def nodes(xp)
+-          doc.elements.to_a(xp)
+-        end
+-      end
+-
+-      class Queue
+-        attr_accessor :name, :pathinfo, :domain, :visibility_timeout
+-
+-        def self.from_url url
+-          return Queue.new($3,$2,$1) if url =~ /^http:\/\/(.+)\/(.+)\/(\w+)$/
+-          raise "Bad Queue URL: #{url}"
+-        end
+-
+-        def queue_url
+-          "/#{pathinfo}/#{name}"
+-        end
+-
+-        def initialize name, pathinfo, domain, vt=nil
+-          @name, @pathinfo, @domain, @visibility_timeout = name, pathinfo, domain, vt
+-        end
+-
+-        def to_s
+-          "<AmazonSQS::Queue name='#{name}' url='#{queue_url}' domain='#{domain}'>"
+-        end
+-      end
+-
+-      # based on stomp message, has pointer to the SQSResponseObject
+-      class Message
+-        attr_accessor :headers, :id, :body, :command, :response, :queue
+-        
+-        def self.from_element e, response, queue
+-          Message.new(response.headers, e.elements['MessageId'].text, e.elements['MessageBody'].text, response, queue)
+-        end
+-      
+-        def initialize headers, id, body, response, queue, command='MESSAGE'
+-          @headers, @id, @body, @response, @queue, @command =  headers, id, body, response, queue, command
+-          headers['destination'] = queue.name
+-        end
+-      
+-        def to_s
+-          "<AmazonSQS::Message id='#{id}' body='#{body}' headers='#{headers.inspect}' command='#{command}' response='#{response}'>"
+-        end
+-      end
+-   
+-    end
+-  end
+-end
+
+Index: jms.rb
+===================================================================
+--- jms.rb	(revision 107)
++++ jms.rb	(working copy)
+@@ -4,7 +4,7 @@
+ include Java
+ 
+ import javax.naming.InitialContext
+-import javax.jms.MessageListener
++ import javax.jms.MessageListener
+ 
+ module ActiveMessaging
+   module Adapters
+Index: new.rb
+===================================================================
+--- new.rb	(revision 0)
++++ new.rb	(revision 0)
+@@ -0,0 +1 @@
++""