coronet 0.0.1 → 0.0.2

data/Coronet.gemspec

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path('../lib/Coronet/version', __FILE__)
+require File.expand_path('../lib/coronet/version', __FILE__)
 
 Gem::Specification.new do |gem|
   gem.authors       = ["Joseph Weissman"]

data/README.md

@@ -20,7 +20,7 @@ Or install it yourself as:
 
 ## Usage
 
-Coronet requires the definition of message formats, transports, service entry/end-points and mediation rules. Once these are defined, you can construct 'service layers' which automatically mediate messages.
+Coronet requires the definition of message formats, transports, service entry/end-points and mediation patterns. Once these are defined, it is straightforward to construct a message-transformation and mediation service using Coronet.
 
 ### Message Formats
 
@@ -43,11 +43,6 @@ Eventually there should be mappers which can transform hash keys.
 	end
 
 
-### Transformation Rules
-
-*Transformation rules* adapt one message format to another. Eventually this may support
-manipulation/mapping of key names.
-
 ### Transport Mechanisms
 
 *Transport mechanisms* encapsulate functional requirements for message transport to 
@@ -75,27 +70,51 @@ being transformed, transported to remote endpoints, the responses gathered,
 transformation rules applied, and the initiating actor (client) being sent 
 the transformed response.
 
-## Example
-
-The following simple example should start the Coronet engine on localhost:10000,
-listening for XML requests via TCP, and mediate the requests to localhost:10001
-in YML over TCP.
-
-	require 'coronet'
+## Examples
+
+Specifying explicit constructors for clarity, here is perhaps the most verbose
+way to setup a mediation framework with Coronet. The example below starts a mediation service
+listening on $mediation_port for XML messages over binary-length-prefixed TCP,
+transforms these messages to YAML, and mediates them to a remote host listening
+at $host_port.
+
+	class SimpleMediator < Mediator
+	  with_listener Listener.new($mediator_port, 
+	                    Protocol.new(
+	                        MessageFormat::XmlMessageFormat.new, 
+	                        TransportMechanism::LengthPrefixedTcpTransport.new))
+                        
+	  for_endpoint RemoteEndpoint.new('localhost', $host_port, 
+	                  Protocol.new(
+	                    MessageFormat::YamlMessageFormat.new, 
+	                    TransportMechanism::LengthPrefixedTcpTransport.new))
+	end
+	
+	# to launch the service, just call the class method 'start_listening'
+	SimpleMediator.start_listening
 	
-	tcp = Coronet::TransportMechanism::LengthPrefixedTcpTransport.new
-	xml = Coronet::MessageFormat::XmlMessageFormat.new
-	yml = Coronet::MessageFormat::YamlMessageFormat.new
+The following example makes fuller use of the built-in DSL, and is accordingly
+much less verbose. The same mediation service is created:
 
-	mediator = Coronet::Mediator.new do
-	  local  xml, tcp, 10000
-	  remote yml, tcp, 'localhost', 10001        
+	class SimpleMediatorUsingDSL < Mediator
+	  listener $mediator_port, xml_via_tcp
+	  endpoint 'localhost', $host_port, yaml_via_tcp
+	end
+	
+You can provide custom processing instructions to the mediation framework. For
+instance, you might want to log every request/response pattern to the database;
+or simply keep track of how many messages you've processed. Here is an example
+of utilizing these callbacks:
+
+	class SimpleMediatorWithCallbacks < SimpleMediatorUsingDSL
+	  preprocess  do |req|
+		# do something with request object 'req'
+	  end
+	
+	  postprocess do |req, rsp| 
+		# do something with request and response objects 'req' and 'rsp'
+	  end
 	end
-
-	mediator.start
-
-
-
 
 ## Contributing
 

data/Rakefile

@@ -1,2 +1,8 @@
 #!/usr/bin/env rake
 require "bundler/gem_tasks"
+task :default => [:spec]
+
+desc "Run focused behavior examples"
+task :spec do
+  exec "bundle exec rspec -cf doc --pattern spec/**/*.spec,spec/coronet/**/*.spec"
+end

data/lib/coronet.rb

@@ -1,5 +1,5 @@
-require "Coronet/version"
+require "coronet/version"
 
 module Coronet
   # Your code goes here...
-end
+end

data/lib/coronet/listener.rb

@@ -2,24 +2,20 @@ module Coronet
   class Listener < GServer
     attr_accessor :port
     attr_accessor :protocol
-    attr_accessor :callback
+    attr_accessor :mediator_klass
     
-    def initialize(port, protocol, callback=nil)
+    def initialize(port, protocol) #, mediator_klass) #callback=nil)
       @port     = port
       @protocol = protocol
-      @callback = callback
-      
-      # start listening on port
       super(port)
     end
     
+    def uses_mediator_class(mediator_klass); @mediator_klass = mediator_klass; end
+    
     def serve(io)
       request = @protocol.read(io)
-      puts "--- listener invoking callback with request: #{request}"
-      response = callback.call(request)
-      puts "--- listener got response: #{response}"
+      response = @mediator_klass.handle(request)
       @protocol.write(response, io)
-      # io.close
     end
   end
 end

data/lib/coronet/mediator.rb

@@ -1,43 +1,69 @@
 module Coronet
   class Mediator
-    attr_accessor :listener, :remote_endpoint
     
-    def initialize(opts={}, &block) 
-      with_listener(opts[:listener])  if opts.has_key? :listener
-      using_endpoint(opts[:endpoint]) if opts.has_key? :endpoint
-      
-      instance_eval &block if block_given?
-    end
-    
-    def with_listener(listener)
-      @listener = listener
-      @listener.callback = method(:handle)
-      self
-    end
-    
-    def using_endpoint(remote_endpoint)
-      @remote_endpoint = remote_endpoint
-      self
+    # proxy start/stop to dedicated listener
+    def self.start_listener; @@listener.start; end
+    def self.stop_listener; @@listener.stop;   end
+    def self.listen(&block)
+      unless block_given?
+        start_listener 
+      else
+        start_listener
+        block.call
+        stop_listener
+      end
     end
     
-    def local(message_format, transport_mechanism, port)
-      protocol = Protocol.new(message_format, transport_mechanism)
-      listener = Listener.new(port, protocol)
-      with_listener(listener)
-    end
-    
-    def remote(message_format, transport_mechanism, remote_host, remote_port)
-      protocol = Protocol.new(message_format, transport_mechanism)
-      endpoint = RemoteEndpoint.new(remote_host, remote_port, protocol)
-      using_endpoint(endpoint)
+    def self.handle(request)
+      if defined? @@preprocess_handler
+        @@preprocess_handler.call(request) 
+      end
+      
+      response = @@remote_endpoint.transmit(request)
+      
+      if defined? @@postprocess_handler
+        @@postprocess_handler.call(request, response) 
+      end
+      
+      return response
     end
-
-    # proxy start/stop to listener
-    def start; @listener.start; end
-    def stop; @listener.stop;   end
     
-    def handle(request)
-      @remote_endpoint.transmit(request)
+    # DSL support
+    class << self
+      # callbacks
+      def preprocess(&block);  puts "--- pre-handler assigned";  @@preprocess_handler  = block; end
+      def postprocess(&block); puts "--- post-handler assigned"; @@postprocess_handler = block; end
+      
+      # mediation config
+      def with_listener(listener)
+        @@listener = listener
+        @@listener.uses_mediator_class(self)        
+      end
+      
+      def listener(port, proto)
+        with_listener(Listener.new(port, proto))
+      end
+      
+      def for_endpoint(remote_endpoint)
+        @@remote_endpoint = remote_endpoint
+      end
+      
+      def endpoint(host, port, proto)
+        for_endpoint(RemoteEndpoint.new(host, port, proto))
+      end
+      
+      # message formats
+      def yaml; MessageFormat::YamlMessageFormat.new; end
+      def xml;  MessageFormat::XmlMessageFormat.new;  end
+      
+      # xport
+      def length_prefixed_tcp; TransportMechanism::LengthPrefixedTcpTransport.new; end
+      
+      # protocol
+      def protocol(format, transport); Protocol.new(format, transport); end
+      
+      def yaml_via_tcp; protocol(yaml, length_prefixed_tcp); end
+      def xml_via_tcp; protocol(xml, length_prefixed_tcp); end
     end
     
   end

data/lib/coronet/message_format/xml_message_format.rb

@@ -3,12 +3,16 @@ module Coronet
     class XmlMessageFormat < Base
       # transform xml string to hash
       def unpack(xml_str)
-        XmlSimple.xml_in(xml_str, forcearray: false, keeproot: true)
+       # puts "--- xml message format attempting to unpack: #{xml_str}"
+        unpacked = XmlSimple.xml_in(xml_str, forcearray: false, keeproot: true)
+        unpacked = unpacked['opt'] if unpacked.has_key? 'opt'
+       # puts "--- unpacked: #{unpacked}"
+        unpacked
       end
       
       # transform hash to xml string
-      def pack(hash)
-        XmlSimple.xml_out(hash, noattr: true, rootname: nil).strip!
+      def pack(hash, root='opt')
+        XmlSimple.xml_out(hash, noattr: true, rootname: root).strip!
       end
     end
   end

data/lib/coronet/protocol.rb

@@ -9,21 +9,26 @@ module Coronet
     end
     
     def read(io)
-      packed = @transport_mechanism.read(io)
-      unpacked = @message_format.unpack(packed)
-      unpacked
+      # packed = 
+      # unpacked = 
+      @message_format.unpack(@transport_mechanism.read(io))
+      # unpacked
     end
     
     def write(data, io)
-      packed = @message_format.pack(data)
-      @transport_mechanism.write(packed, io)
+      @transport_mechanism.write(@message_format.pack(data), io)
     end
     
     def transmit(request, host, port)
+      # puts "=== opening connection to #{host}:#{port}"
       io = @transport_mechanism.open(host,port)
+      # puts "--- writing #{request} to #{host}:#{port}"
       write(request, io)
+      # puts "=== reading response from #{host}:#{port}"
       response = read(io)
+      # puts "--- closing socket to #{host}:#{port}"
       @transport_mechanism.close(io)
+      # puts "=== returning response #{response} from #{host}:#{port}"
       response
     end
   end

data/lib/coronet/support/echo_server.rb

@@ -6,6 +6,7 @@ module Coronet
         super(port, *args)
         @tcp = TransportMechanism::LengthPrefixedTcpTransport.new
       end
+      
       def serve(io)
         @tcp.write(@tcp.read(io), io)
       end

data/lib/coronet/support/request_reply_server.rb

@@ -0,0 +1,29 @@
+module Coronet
+  module Support
+    
+    class RequestReplyServer < GServer
+      def initialize(port=12345, format=MessageFormat::YamlMessageFormat.new, *args)
+        super(port, *args)
+        @tcp = TransportMechanism::LengthPrefixedTcpTransport.new
+        @format = format
+        @count = 0
+      end
+      
+      def serve(io)
+        packed_request = @tcp.read(io)
+        request = @format.unpack(packed_request)
+        response = handle(request)
+        packed_response = @format.pack(response)
+        @tcp.write(packed_response, io)
+      end
+      
+      def handle(request)
+        @count += 1
+        # puts "--- mock host handling request #{@count}: #{request}"
+        request['hello'] = 'client' if request.has_key? 'hello'
+        request
+      end
+    end
+
+  end
+end

data/lib/coronet/transport_mechanism/base.rb

@@ -4,24 +4,14 @@ module Coronet
       include Contractual::Interface
     
       must :open, :host, :port
-      must :write, :data
-      must :read
-      must :close
-      
-      # attr_accessor :host, :port
-      # attr_accessor :io
-      
-      # def initialize #(host, port)
-        # @host = host
-        # @port = port
-      # end
+      must :write, :data, :io
+      must :read, :io
+      must :close, :io
     
       def transmit(data, io)
-        # io = open(host, port)
         write(data, io)
         response = read(io)
         close(io)
-        
         response
       end
     end

data/lib/coronet/transport_mechanism/length_prefixed_tcp_transport.rb

@@ -8,21 +8,25 @@ module Coronet
     class LengthPrefixedTcpTransport < Base
       attr_accessor :tcp_socket
       
-      def open(host, port)
-        TCPSocket.open(host, port)
-      end
+      # n.b., for four bytes, can just use 4/'N'
+      LENGTH_HEADER_BYTES = 2
+      LENGTH_HEADER_STORAGE_CLASS = "n"
+      
+      def open(host, port); TCPSocket.open(host, port); end
       
       def read(io)
-        length_header = io.read(2)
-        p length_header
-        length = length_header.unpack("S").first
+        length_header = io.read(LENGTH_HEADER_BYTES)
+        # p length_header
+        length = length_header.unpack(LENGTH_HEADER_STORAGE_CLASS).first
+        # puts "--- TCP READ #{length}"
+        
         io.read(length)
       end
       
       def write(data, io)
+        # puts "--- TCP WRITE #{data}"
         length = data.size
-        prefix = to_byte_array(length).pack("S")
-
+        prefix = [length].pack(LENGTH_HEADER_STORAGE_CLASS)
         io.print(prefix)
         io.print(data)
       end
@@ -30,17 +34,6 @@ module Coronet
       def close(io)
         io.close
       end
-      
-      private 
-        def to_byte_array(num)
-          result = Array.new
-          begin
-            result << (num & 0xff)
-            num >>= 8
-          end until (num == 0 || num == -1) && (result.last[7] == num[7])
-          result.reverse
-        end
-      
     end
   end
 end

data/lib/coronet/version.rb

@@ -0,0 +1,3 @@
+module Coronet
+  VERSION = "0.0.2"
+end

data/spec/coronet/listener.spec

@@ -17,7 +17,6 @@ module Coronet
     
     module Echo
       def self.handle(request)
-        # puts "--- echo server handling request: #{request}"
         request
       end
     end
@@ -28,7 +27,8 @@ module Coronet
       xml = MessageFormat::XmlMessageFormat.new
       xml_via_tcp = Protocol.new(xml, tcp)
       
-      echo_listener = Listener.new(12345, xml_via_tcp, Echo.method(:handle))
+      echo_listener = Listener.new(12345, xml_via_tcp)
+      echo_listener.uses_mediator_class(Echo)
       echo_listener.start
       
       msg = { 'hello' => 'world' }

data/spec/coronet/mediator.spec

@@ -3,7 +3,7 @@ require 'gserver'
 require 'contractual'
 require 'xmlsimple'
 
-require 'coronet/support/echo_server'
+require 'coronet/support/request_reply_server'
 
 require 'coronet/message_format/base'
 require 'coronet/message_format/xml_message_format'
@@ -14,68 +14,130 @@ require 'coronet/transport_mechanism/length_prefixed_tcp_transport'
 
 require 'coronet/protocol'
 require 'coronet/listener'
-require 'coronet/transformation_rule'
 require 'coronet/remote_endpoint'
 
 require 'coronet/mediator'
 
 module Coronet
   
+  include TransportMechanism
+  include MessageFormat
+  include Support
+  
+  $mediator_port, $host_port = 10000, 10001
+  
   describe Mediator, "mediates between clients and servers" do
-    # it "mediates between client and server"
-    # it "transforms message formats"
-    it "adapts transport mechanisms and protocols" do
-      tcp = TransportMechanism::LengthPrefixedTcpTransport.new
-      
-      xml = MessageFormat::XmlMessageFormat.new
-      yml = MessageFormat::YamlMessageFormat.new
-      
-      xml_via_tcp = Protocol.new(xml, tcp)
-      yml_via_tcp = Protocol.new(yml, tcp)
-      
-      xml_to_yml = TransformationRule.new(xml, yml)
-      
-      listener = Listener.new(10000, xml_via_tcp)
-      
-      echo_server = Support::EchoServer.new(10001)
-      echo_server_endpoint = RemoteEndpoint.new('localhost', 10001, yml_via_tcp)
-      
-      mediator = Mediator.new listener: listener, endpoint: echo_server_endpoint # , xml_to_yml)
-      
-      echo_server.start
-      mediator.start
-      
-      msg = { 'hello' => 'world' }
-      xml_via_tcp.transmit(msg, 'localhost', 10000).should == msg
+    
+    before :each do
+      @xml_over_tcp = Protocol.new(XmlMessageFormat.new, LengthPrefixedTcpTransport.new)
       
-      mediator.stop
-      echo_server.stop
+      @request = { 'hello' => 'server' }      
+      @expected_response = { 'hello' => 'client' }
     end
     
-    it "supports a basic DSL" do
+    # after :each do
+    # end
+    
+    it "adapts protocols" do
       
-      tcp = TransportMechanism::LengthPrefixedTcpTransport.new
-      xml = MessageFormat::XmlMessageFormat.new
-      yml = MessageFormat::YamlMessageFormat.new
+      class SimpleMediator < Mediator
+        with_listener Listener.new($mediator_port, 
+                          Protocol.new(
+                              MessageFormat::XmlMessageFormat.new, 
+                              TransportMechanism::LengthPrefixedTcpTransport.new))
+
+        for_endpoint RemoteEndpoint.new('localhost', $host_port, 
+                        Protocol.new(
+                          MessageFormat::YamlMessageFormat.new, 
+                          TransportMechanism::LengthPrefixedTcpTransport.new))
+      end
       
-      mediator = Mediator.new do
-        local  xml, tcp, 10000
-        remote yml, tcp, 'localhost', 10001        
+      host = RequestReplyServer.new($host_port, YamlMessageFormat.new)        
+      host.start
+      SimpleMediator.listen do
+
+        @xml_over_tcp.transmit(@request, 'localhost', $mediator_port).should == @expected_response
       end
+      host.stop
+    end
+    
+    it "supports a simple DSL" do
       
-      echo_server = Support::EchoServer.new(10001)
+      class SimpleMediatorUsingDSL < Mediator
+        listener $mediator_port, xml_via_tcp
+        endpoint 'localhost', $host_port, yaml_via_tcp
+      end
       
-      msg = { 'hello' => 'world' }
-      xml_via_tcp = Protocol.new(xml, tcp)
+      host = RequestReplyServer.new($host_port, YamlMessageFormat.new)
+      host.start
       
-      mediator.start
-      echo_server.start
+      SimpleMediatorUsingDSL.listen do
+        @xml_over_tcp.transmit(@request, 'localhost', $mediator_port).should == @expected_response        
+      end
+      host.stop      
+    end
+    
+    it "handles callbacks" do
       
-      xml_via_tcp.transmit(msg, 'localhost', 10000).should == msg
+
+      $preprocess_invoked, $postprocess_invoked = false, false
+      class SimpleMediatorWithCallbacks < SimpleMediatorUsingDSL
+        preprocess  do |req|  
+          $preprocess_invoked = true
+        end
+
+        postprocess do |req, rsp| 
+          $postprocess_invoked = true
+        end
+      end
       
-      echo_server.stop
-      mediator.stop
+      host = RequestReplyServer.new($host_port, YamlMessageFormat.new)
+      host.start
+      SimpleMediatorWithCallbacks.listen do
+        @xml_over_tcp.transmit(@request, 'localhost', $mediator_port).should == @expected_response
+      end
+      host.stop
+      $preprocess_invoked.should == true
+      $postprocess_invoked.should == true
+    end
+    
+    it "supports concurrent request handling" do
       
+      class SimpleMediatorWithLogging < SimpleMediatorUsingDSL
+        postprocess do |req, rsp| 
+          # puts "--- request #{req} got response #{rsp}"
+        end
+      end
+
+      host = RequestReplyServer.new($host_port, YamlMessageFormat.new)
+      host.start
+      SimpleMediatorWithLogging.listen do
+
+        
+        client_count = 2
+        message_count = 3
+        
+        clients = []
+        (1..client_count).each do |n|
+          client = Thread.new do
+            message_count.times do |index|
+              msg = { 'hello' => 'server', 'client' => n, 'index' => index }
+              xml_over_tcp = Protocol.new(XmlMessageFormat.new, LengthPrefixedTcpTransport.new)
+              # puts "--- client #{n} about to transmit message #{msg}"
+              response = xml_over_tcp.transmit(msg, 'localhost', $mediator_port)
+              # puts "--- client #{n} got response #{response}"
+              response['hello'].should == 'client'
+              response['client'].to_i.should == n
+              response['index'].to_i.should == index
+              sleep 0.1
+            end
+          end
+          clients << client
+          
+        end
+        clients.each { |client| client.join }
+      end
+      host.stop
     end
   end
 end

data/spec/coronet/message_format/base.spec

@@ -22,12 +22,12 @@ module Coronet
     
       it "should handle xml" do
         @xml.unpack(@xml_data).should == { 'hello' => 'world' }
-        @xml.pack(@xml.unpack(@xml_data)).should == @xml_data
+        @xml.pack(@xml.unpack(@xml_data), nil).should == @xml_data
       end
 
       it "should handle transforming yml to xml (and vice versa)" do
         @xml.unpack(@xml_data).should == @yml.unpack(@yml_data)
-        @xml.pack(@yml.unpack(@yml_data)).should == @xml_data
+        @xml.pack(@yml.unpack(@yml_data), nil).should == @xml_data
         @yml.pack(@xml.unpack(@xml_data)).should == @yml_data
       end
     end

data/spec/coronet/protocol.spec

@@ -22,7 +22,7 @@ module Coronet
       xml = MessageFormat::XmlMessageFormat.new
       xml_via_tcp = Protocol.new(xml, tcp)
       
-      msg = { 'hello' => 'world' }
+      msg = { 'hello' => 'world', 'whats' => 'up' }
       xml_via_tcp.transmit(msg, 'localhost', 12345).should == msg
       
       echo.stop

data/spec/coronet/transport_mechanism/base.spec

@@ -12,11 +12,13 @@ module Coronet
     describe Base, "encapsulates transport-layer functionality" do
       it "supports interaction with remote services" do
         echo = Support::EchoServer.new(12345)
-        tcp  = LengthPrefixedTcpTransport.new# ('localhost', 12345)
+        tcp  = LengthPrefixedTcpTransport.new
         
         echo.start
         io   = tcp.open('localhost', 12345)
-        tcp.transmit("hello", io).should == 'hello'
+        msg = "data" *1250
+        # p msg
+        tcp.transmit(msg, io).should == msg
         echo.stop
       end   
     end

data/test/example.rb

@@ -0,0 +1,14 @@
+require 'coronet'
+
+tcp = Coronet::TransportMechanism::LengthPrefixedTcpTransport.new
+xml = Coronet::MessageFormat::XmlMessageFormat.new
+yml = Coronet::MessageFormat::YamlMessageFormat.new
+
+
+# 
+# mediator = Coronet::Mediator.new do
+#   local  xml, tcp, 10000
+#   remote yml, tcp, 'localhost', 10001        
+# end
+# 
+# mediator.start

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coronet
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-26 00:00:00.000000000 Z
+date: 2012-04-27 00:00:00.000000000 Z
 dependencies: []
 description: Coronet is a simple protocol adaption framework
 email:
@@ -24,7 +24,6 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- lib/Coronet/version.rb
 - lib/coronet.rb
 - lib/coronet/listener.rb
 - lib/coronet/mediator.rb
@@ -34,17 +33,18 @@ files:
 - lib/coronet/protocol.rb
 - lib/coronet/remote_endpoint.rb
 - lib/coronet/support/echo_server.rb
-- lib/coronet/transformation_rule.rb
+- lib/coronet/support/request_reply_server.rb
 - lib/coronet/transport_mechanism/base.rb
 - lib/coronet/transport_mechanism/length_prefixed_tcp_transport.rb
+- lib/coronet/version.rb
 - spec/coronet/listener.spec
 - spec/coronet/mediator.spec
 - spec/coronet/message_format/base.spec
 - spec/coronet/protocol.spec
 - spec/coronet/remote_endpoint.spec
-- spec/coronet/transformation_rule.spec
 - spec/coronet/transport_mechanism/base.spec
 - spec/coronet_spec.rb
+- test/example.rb
 homepage: 
 licenses: []
 post_install_message: 

data/lib/Coronet/version.rb

@@ -1,3 +0,0 @@
-module Coronet
-  VERSION = "0.0.1"
-end

data/lib/coronet/transformation_rule.rb

@@ -1,16 +0,0 @@
-module Coronet
-  class TransformationRule
-    attr_accessor :in, :out
-    
-    def initialize(incoming, outgoing)
-      @in = incoming
-      @out = outgoing
-    end
-    
-    def apply(message)
-      @in.transform(message, @out)
-    end
-    
-    def inverse; TransformationRule.new(@out, @in); end
-  end
-end

data/spec/coronet/transformation_rule.spec

@@ -1,29 +0,0 @@
-require 'contractual'
-require 'xmlsimple'
-require 'psych'
-
-require 'coronet/message_format/base'
-require 'coronet/message_format/xml_message_format'
-require 'coronet/message_format/yaml_message_format'
-
-require 'coronet/transformation_rule'
-
-module Coronet
-  describe TransformationRule, "transforms messages into other formats" do
-    before :each do
-      @yml, @xml = MessageFormat::YamlMessageFormat.new, MessageFormat::XmlMessageFormat.new
-      @yml_data = "---\nhello: world\n"
-      @xml_data = "<hello>world</hello>"
-    end
-    
-    it "transforms xml to yml" do
-      rule = TransformationRule.new(@xml, @yml)
-      rule.apply(@xml_data).should == @yml_data
-    end
-    
-    it "transforms yml to xml" do
-      rule = TransformationRule.new(@yml, @xml)
-      rule.apply(@yml_data).should == @xml_data
-    end    
-  end
-end