melomel 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Ben Johnson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,141 @@
+melomel.rb -- A Ruby interface to Melomel
+=========================================
+
+## DESCRIPTION
+
+Melomel.rb is a library that allows Ruby to communicate with an application
+running within the Flash virtual machine. For more information on Melomel,
+visit the Melomel repository:
+
+http://github.com/benbjohnson/melomel
+
+Melomel.rb follows the rules of [Semantic Versioning](http://semver.org/) and
+uses [TomDoc](http://tomdoc.org/) for inline documentation.
+
+
+## INSTALLATION
+
+To install Melomel.rb simply use RubyGems:
+
+    $ [sudo] gem install melomel
+
+Melomel needs to be embedded and running in the application you're trying to
+connect to. Please see the Melomel repository for instructions on installation.
+
+
+## GETTING STARTED
+
+The first step to using Melomel is to install the Flash SWC in your application.
+Once the SWC is in your application, setup in your Ruby project is simple.
+
+In your Ruby file, simply call the `connect()` method on `Melomel`:
+
+	require 'melomel'
+	Melomel.connect()
+
+The `connect()` method is a blocking method so it won't proceed until it's done.
+After it's connected, there are several actions you can perform:
+
+1. Create Object
+1. Get Class
+1. Get Property
+1. Set Property
+1. Invoke Method
+
+## API
+
+### Overview
+
+Melomel communicates to the Flash virtual machine over a socket connection
+using XML. The protocol is simple and is meant to proxy all data access calls
+to the Flash virtual machine. This means that only primitives (strings, numbers
+and booleans) are copied but all objects are accessed by reference. By proxying
+objects, all data stays in the Flash virtual machine and there are no syncing
+issues.
+
+### Create Object
+
+To create an object, use the `create_object()` method on `Melomel`:
+
+    point = Melomel.create_object('flash.geom.Point')
+
+The object returned is a proxy object so any actions performed on it in Ruby
+will be performed on the ActionScript object in the Flash virtual machine.
+
+### Get Class
+
+You can retrieve a class to call static methods and properties. Since classes
+are objects in ActionScript, they work identically in Melomel.
+
+    app = Melomel.get_class('mx.core.FlexGlobals')
+    app.topLevelApplication.name  = 'Melomel App!'
+
+This Flex 4 example updates the name of the application to "Melomel App!".
+
+### Get Property & Set Property
+
+Getting and setting properties is handled transparently when using the object
+proxies.
+
+    point = Melomel.create_object('flash.geom.Point')
+    point.x = 30
+    point.set_property('y') = 40
+	p "pos: #{point.x}, #{point.y}"
+	p "length: #{point.get_property('length')}"
+
+Property accessors on an object proxy are automatically used to retrieve the
+property value of the Flash object. You can also use the `get_property()`
+method when accessing properties and the `set_property()` method when mutating
+properties.
+
+### Invoke Method
+
+Invoking methods is also handled transparently when using object proxies.
+
+_IMPORTANT: There a catch! Methods without any parameters must have a bang
+(`!`) character appended to their method name when calling directly on an
+object proxy._
+
+	clipboard = Melomel.get_class('flash.desktop.Clipboard').generalClipboard
+	data = clipboard.getData('air:text')
+	data = clipboard.invoke_method('getData', 'air:text')
+	clipboard.clear!()
+	clipboard.invoke_method('clear')
+
+In this example, the `getData` method could be called on the object directly
+because it had more than one argument. The `clear` method, however, required
+that a bang character be appended to the name or that the `invoke_method` be
+used.
+
+
+## HACKING
+
+To get started with working with the source, start by running Bundler to get all
+your dependencies:
+
+	[sudo] bundle install
+
+If you are adding new features, please add test coverage to all code that you
+write. Run the test suite with `rake`:
+
+	rake test
+
+
+## CONTRIBUTE
+
+If you'd like to contribute to Melomel.rb, please fork the repo on GitHub:
+
+http://github.com/benbjohnson/melomel.rb
+
+To get all of the dependencies, install the gem first. The best way to get
+your changes merged back into core is as follows:
+
+1. Clone your fork locally
+1. Create a named topic branch to contain your change
+1. Code
+1. All code must have RSpec test coverage. Run `rake` to ensure everything
+   passes.
+1. If you are adding new functionality, document it in the README
+1. If necessary, rebase your commits into logical chunks, without errors
+1. Push the branch up to GitHub
+1. Send me a pull request for your branch

data/lib/melomel/bridge/messaging.rb

@@ -0,0 +1,112 @@
+require 'nokogiri'
+
+# These add-on methods enable the message encoding and decoding.
+module Melomel
+  class Bridge
+    # Creates an object in the Flash virtual machine and returns the reference
+    # to it.
+    def create_object(class_name)
+      send("<create class=\"#{class_name}\"/>")
+      parse_message_value(Nokogiri::XML(receive()).root)
+    end
+
+    # Retrieves a reference to a class in the Flash virtual machine.
+    def get_class(class_name)
+      send("<get-class name=\"#{class_name}\"/>")
+      parse_message_value(Nokogiri::XML(receive()).root)
+    end
+
+    # Retrieves a property of an object in the Flash virtual machine
+    def get_property(proxy_id, property)
+      send("<get object=\"#{proxy_id}\" property=\"#{property}\"/>")
+      parse_message_value(Nokogiri::XML(receive()).root)
+    end
+
+    # Sets a property on an object in the Flash virtual machine
+    def set_property(proxy_id, property, value)
+      # Create message and format value to set
+      xml = Nokogiri::XML("<set object=\"#{proxy_id}\" property=\"#{property}\"><arg/></set>")
+      format_message_value(xml.at_xpath('/set/arg'), value)
+      
+      # Send & Receive
+      send(xml.root.to_xml(:indent => 0))
+      parse_message_value(Nokogiri::XML(receive()).root)
+    end
+
+    # Invokes a method on an object in the Flash virtual machine
+    def invoke_method(proxy_id, method_name, *args)
+      xml = Nokogiri::XML("<invoke object=\"#{proxy_id}\" method=\"#{method_name}\"><args/></invoke>")
+      
+      # Loop over and add arguments to call
+      args_node = xml.at_xpath('invoke/args')
+      args.each do |arg|
+        arg_node = Nokogiri::XML::Node.new('arg', xml)
+        format_message_value(arg_node, arg)
+        args_node.add_child(arg_node)
+      end
+      
+      # Send and receive
+      send(xml.root.to_xml(:indent => 0))
+      parse_message_value(Nokogiri::XML(receive()).root)
+    end
+
+    # Creates an object proxy from a hash
+    def create_hash(hash)
+      proxy = create_object('Object')
+      hash.each_pair do |k,v|
+        v = create_hash(v) if !v.nil? && v.is_a?(Hash)
+        proxy.set_property(k, v)
+      end
+      return proxy
+    end
+
+    # Formats a Ruby value into an XML message
+    def format_message_value(xml, value)
+      # Automatically convert simple hashes to objects
+      if(!value.nil? && value.is_a?(Hash))
+        value = create_hash(value)
+      end
+      
+      if value.nil?
+        xml['dataType'] = 'null'
+      elsif value.class == Fixnum || value.class == Bignum
+        xml['value'] = value.to_s
+        xml['dataType'] = 'int'
+      elsif value.class == Float
+        xml['value'] = value.to_s
+        xml['dataType'] = 'float'
+      elsif value == true || value == false
+        xml['value'] = value.to_s
+        xml['dataType'] = 'boolean'
+      elsif value.class == Melomel::ObjectProxy
+        xml['value'] = value.proxy_id.to_s
+        xml['dataType'] = 'object'
+      elsif value.class == String
+        xml['value'] = value
+        xml['dataType'] = 'string'
+      end
+    end
+
+    # Parses a return message and converts it into an appropriate type
+    def parse_message_value(xml)
+      value = xml['value']
+      data_type = xml['dataType']
+      
+      if data_type == 'null'
+        return nil
+      elsif data_type == 'int'
+        return value.to_i
+      elsif data_type == 'float'
+        return value.to_f
+      elsif data_type == 'boolean'
+        return value == 'true'
+      elsif data_type == 'object'
+        return Melomel::ObjectProxy.new(self, value.to_i)
+      elsif data_type == 'string' || data_type.nil?
+        return value
+      else
+        raise UnrecognizedTypeError, "Unknown type: #{data_type}"
+      end
+    end
+  end
+end

data/lib/melomel/bridge/ui.rb

@@ -0,0 +1,55 @@
+# These add-on methods provide ease of use utility methods.
+module Melomel
+  class Bridge
+    # Finds a list of display objects matching a class and hash of properties.
+    def find_all(class_name, root={}, properties={})
+      # Merge hashes if no root is specified
+      if root.is_a?(Hash)
+        properties.merge!(root)
+        root = nil
+      end
+      
+      # Retrieve object
+      get_class('melomel.core.UI').findAll(class_name, root, properties)
+    end
+
+    # Finds a display object by class and properties.
+    def find(class_name, root={}, properties={})
+      # Merge hashes if no root is specified
+      if root.is_a?(Hash)
+        properties.merge!(root)
+        root = nil
+      end
+      
+      # Retrieve object
+      get_class('melomel.core.UI').find(class_name, root, properties)
+    end
+
+
+    # Imitates a click on a component
+    def click(component, properties={})
+      get_class('melomel.core.UI').click(component, properties)
+    end
+
+    # Imitates a double click on a component
+    def double_click(component, properties={})
+      get_class('melomel.core.UI').doubleClick(component, properties)
+    end
+
+
+    # Imitates a key down on a component
+    def key_down(component, char, properties={})
+      get_class('melomel.core.UI').keyDown(component, char, properties)
+    end
+
+    # Imitates a key up on a component
+    def key_up(component, char, properties={})
+      get_class('melomel.core.UI').keyUp(component, char, properties)
+    end
+
+    # Imitates a key press on a component
+    def key_press(component, char, properties={})
+      get_class('melomel.core.UI').keyPress(component, char, properties)
+    end
+  end
+end

data/lib/melomel/bridge.rb

@@ -0,0 +1,76 @@
+require 'socket'
+require 'melomel/bridge/messaging'
+require 'melomel/bridge/ui'
+    
+# The bridge manages the connection to the Flash virtual machine. All messages
+# sent to the virtual machine are passed through this object.
+module Melomel
+  class Bridge
+    attr_accessor :host, :port
+    
+    def initialize(host='localhost', port=10101)
+      self.host = host
+      self.port = port
+      server, @socket = nil, nil
+    end
+    
+    # Opens a socket connection to listen for incoming bridge connections. This
+    # method automatically handles requests for the policy file.
+    def connect()
+      disconnect()
+      
+      # Listen for connections
+      server = TCPServer.open(host, port)
+      
+      # Retrieve socket and check for initial handshake
+      while(@socket.nil?) do
+        socket = server.accept()
+        data = socket.gets("\x00").chomp("\x00")
+        
+        # Send policy file if requested.
+        if(data == '<policy-file-request/>')
+          send_policy_file(socket)
+        # Otherwise open connection and continue
+        elsif(data == '<connect/>')
+          @socket = socket
+        end
+      end
+
+      server.close();
+    end
+
+    # Closes any open connection to a Flash virtual machine.
+    def disconnect()
+      begin
+        @socket.close()
+      rescue
+      end
+
+      @socket = nil
+    end
+
+    # Sends a message over to the Flash bridge.
+    def send(message)
+      @socket.puts("#{message}\x00")
+    end
+
+    # Receives a message from the Flash bridge. This is a blocking call.
+    def receive()
+      @socket.gets("\x00").chomp("\x00")
+    end
+
+
+    private
+    def send_policy_file(socket)
+      policy = ''
+      policy << '<?xml version="1.0"?>'
+      policy << '<!DOCTYPE cross-domain-policy SYSTEM "http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd">'
+      policy << '<cross-domain-policy>'
+      policy << "<allow-access-from domain=\"#{host}\" to-ports=\"#{port}\"/>"
+      policy << '</cross-domain-policy>'
+      socket.send(policy)
+      socket.flush()
+      socket.close()
+    end
+  end
+end

data/lib/melomel/object_proxy.rb

@@ -0,0 +1,58 @@
+# This class as a proxy to an object in the Flash virtual machine. Invoking
+# methods, accessing properties or changing properties on this object will
+# result in a command being sent to Flash to change or access the state of the
+# object within the virtual machine. The Ruby object proxy holds no state.
+#
+# The object proxy works exactly as if the Flash object was a local Ruby object.
+# To do this, the following aliases are made:
+# * Method calls with method names ending in "=" are aliased to #set_property
+# * Method calls without arguments are aliased to #get_property.
+# * Method calls with arguments are aliased to #invoke_method
+module Melomel
+  class ObjectProxy
+    attr_reader :bridge, :proxy_id
+    
+    def initialize(bridge, proxy_id)
+      @bridge   = bridge
+      @proxy_id = proxy_id
+    end
+    
+    # Retrieves the value of a property for the proxied object.
+    def get_property(name)
+      @bridge.get_property(@proxy_id, name)
+    end
+    
+    # Sets the value of a property for the proxied object.
+    def set_property(name, value)
+      @bridge.set_property(@proxy_id, name, value)
+    end
+    
+    # Invokes a method on the proxied object. Arguments passed into the method
+    # are passed through to the invoked method
+    def invoke_method(method_name, *args)
+      @bridge.invoke_method(@proxy_id, method_name, *args)
+    end
+    
+    alias :invoke :invoke_method
+    
+    # Proxies all methods to the appropriate Flash objects.
+    def method_missing(symbol, *args)
+      method_name = symbol.to_s
+      last_char = method_name.to_s[-1,1]
+      
+      # Methods ending in "=" are aliased to set_property
+      if last_char == '='
+        return set_property(method_name.chop, *args)
+      # Methods with arguments are methods
+      elsif args.length > 0
+        return invoke_method(method_name, *args)
+      # Methods ending in '!' are methods
+      elsif last_char == '!'
+        return invoke_method(method_name.chop, *args)
+      # Methods with no arguments are aliased to get_property
+      else
+        return get_property(method_name)
+      end
+    end
+  end
+end

data/lib/melomel/ui.rb

@@ -0,0 +1,44 @@
+# This class provides ease of use utility methods for finding display objects
+# and interacting with them.
+module Melomel
+  class UI
+    class << self
+      # Finds all display objects matching a class and hash of properties.
+      def find_all(class_name, root={}, properties={})
+        Melomel.bridge.find_all(class_name, root, properties)
+      end
+
+      # Finds a display object by class and properties.
+      def find(class_name, root={}, properties={})
+        Melomel.bridge.find(class_name, root, properties)
+      end
+
+
+      # Imitates a click on a component
+      def click(component, properties={})
+        Melomel.bridge.click(component, properties)
+      end
+
+      # Imitates a double click on a component
+      def double_click(component, properties={})
+        Melomel.bridge.double_click(component, properties)
+      end
+
+
+      # Imitates a key down on a component
+      def key_down(component, char, properties={})
+        Melomel.bridge.key_down(component, char, properties)
+      end
+
+      # Imitates a key up on a component
+      def key_up(component, char, properties={})
+        Melomel.bridge.key_up(component, char, properties)
+      end
+
+      # Imitates a key press on a component
+      def key_press(component, char, properties={})
+        Melomel.bridge.key_press(component, char, properties)
+      end
+    end
+  end
+end

data/lib/melomel/version.rb

@@ -0,0 +1,3 @@
+module Melomel
+  VERSION = "0.1.0"
+end

data/lib/melomel.rb

@@ -0,0 +1,34 @@
+require 'melomel/bridge'
+require 'melomel/object_proxy'
+require 'melomel/ui'
+require 'melomel/version'
+
+# This class acts as a singleton instance of the bridge. This is typically the
+# only class you'll need to use. If multiple instances of the bridge are needed
+# (to connect to multiple SWF files), you will need to instantiate and manage
+# the bridge objects manually.
+module Melomel
+  class MelomelError < StandardError; end
+  class UnrecognizedTypeError < MelomelError; end
+
+  class << self
+    attr_reader :bridge
+    
+    # Opens a bridge connection to the SWF file. This is a blocking call and
+    # will wait until a SWF connects before continuing.
+    def connect(host='localhost', port=10101)
+      @bridge = Melomel::Bridge.new(host, port)
+      @bridge.connect();
+    end
+
+    # Retrieves a reference to a class
+    def get_class(class_name)
+      @bridge.get_class(class_name)
+    end
+
+    # Creates an object in the virtual machine.
+    def create_object(class_name)
+      @bridge.create_object(class_name)
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,28 @@
+require 'rubygems'
+require "bundler"
+Bundler.setup
+require 'minitest/autorun'
+require 'mocha'
+
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift(File.join(dir, '..', 'lib'))
+$LOAD_PATH.unshift(dir)
+
+require 'melomel'
+
+class RunnerTestCase < MiniTest::Unit::TestCase
+  def start_runner
+    # Make sure FLEX_HOME is defined
+    raise 'FLEX_HOME environment variable must be set' if ENV['FLEX_HOME'].nil?
+
+    # Open up the sandbox
+    @pid = fork do
+      exec("#{ENV['FLEX_HOME']}/bin/adl target/MelomelRunner-app.xml")
+    end
+    Process.detach(@pid)
+  end
+
+  def stop_runner
+    Process.kill('KILL', @pid)
+  end
+end

data/test/test_bridge.rb

@@ -0,0 +1,61 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), *%w[helper])
+
+class BridgeTestCase < MiniTest::Unit::TestCase
+  def setup
+    @bridge = Melomel::Bridge.new('localhost', 10101)
+  end
+
+  def connect
+    # Mock server
+    @server = mock('server')
+    TCPServer.stubs(:open).returns(@server)
+    TCPServer.any_instance.stubs(:close)
+    
+    # Mock sockets
+    @socket = mock('socket')
+    @socket.expects(:gets).returns("<connect/>\x00")
+    @server.expects(:accept).returns(@socket)
+    @server.expects(:close)
+    
+    # Attempt connection
+    @bridge.connect()
+  end
+
+  def test_should_send_messages_over_socket_connection
+    connect()
+    @socket.expects(:puts).with("<message/>\x00")
+    @bridge.send('<message/>')
+  end
+
+  def test_should_receive_messages_from_socket_connection
+    connect()
+    @socket.expects(:gets).returns("<message/>\x00")
+    assert_equal '<message/>', @bridge.receive()
+  end
+
+  def test_should_send_policy_file_and_connect
+    policy = '<?xml version="1.0"?><!DOCTYPE cross-domain-policy SYSTEM "http://www.macromedia.com/xml/dtds/cross-domain-policy.dtd"><cross-domain-policy><allow-access-from domain="localhost" to-ports="10101"/></cross-domain-policy>';
+    
+    # Mock server
+    server = mock('server')
+    server.expects(:close)
+    TCPServer.expects(:open).returns(server)
+    
+    # Mock policy file
+    policy_socket = mock('policy_socket')
+    policy_socket.expects(:gets).returns("<policy-file-request/>\x00")
+    policy_socket.expects(:send).with(policy)
+    policy_socket.expects(:flush)
+    policy_socket.expects(:close)
+    
+    # Mock regular socket
+    socket = mock('socket')
+    socket.expects(:gets).returns("<connect/>\x00")
+
+    # Server should return policy socket first and then regular socket
+    server.stubs(:accept).returns(policy_socket, socket, nil)
+    
+    # Attempt connection
+    @bridge.connect()
+  end
+end

data/test/test_integration.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), *%w[helper])
+
+class IntegrationTestCase < RunnerTestCase
+  def setup
+    start_runner
+    Melomel.connect()
+  end
+
+  def teardown
+    stop_runner
+  end
+
+  def test_should_get_application_name
+    app = Melomel.get_class('mx.core.FlexGlobals')
+    assert_equal 'Melomel Runner', app.topLevelApplication.name
+  end
+
+  def test_should_get_property
+    runner = Melomel.get_class('MelomelRunner')
+    assert_equal 'bar', runner.foo
+  end
+
+  def test_should_set_property
+    runner = Melomel.get_class('MelomelRunner')
+    runner.name = 'Susy'
+    assert_equal 'Susy', runner.name
+    runner.name = 'John' # TODO: Do not make other tests dependent on this
+  end
+
+  def test_should_invoke_method
+    runner = Melomel.get_class('MelomelRunner')
+    assert_equal 'Hello, John', runner.hello('John')
+  end
+
+  def test_should_create_object
+    point = Melomel.create_object('flash.geom.Point')
+    point.x = 30
+    point.y = 40
+    assert_equal 50, point.length
+  end
+end

data/test/test_messaging.rb

@@ -0,0 +1,109 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), *%w[helper])
+
+class MessagingTestCase < MiniTest::Unit::TestCase
+  def setup
+    @bridge = Melomel::Bridge.new('localhost', 10101)
+  end
+
+
+  #############################################################################
+  #
+  # Message Parsing
+  #
+  #############################################################################
+
+  def test_should_parse_null
+    message = '<return dataType="null"/>'
+    assert_nil @bridge.parse_message_value(Nokogiri::XML(message).root)
+  end
+
+  def test_should_parse_integer
+    message = '<return value="12" dataType="int"/>'
+    assert_equal 12, @bridge.parse_message_value(Nokogiri::XML(message).root)
+  end
+
+  def test_should_parse_float
+    message = '<return value="100.12" dataType="float"/>'
+    assert_equal 100.12, @bridge.parse_message_value(Nokogiri::XML(message).root)
+  end
+
+  def test_should_parse_boolean_true
+    message = '<return value="true" dataType="boolean"/>'
+    assert_equal true, @bridge.parse_message_value(Nokogiri::XML(message).root)
+  end
+
+  def test_should_parse_boolean_false
+    message = '<return value="false" dataType="boolean"/>'
+    assert_equal false, @bridge.parse_message_value(Nokogiri::XML(message).root)
+  end
+
+  def test_should_parse_string
+    message = '<return value="foo" dataType="string"/>'
+    assert_equal 'foo', @bridge.parse_message_value(Nokogiri::XML(message).root)
+  end
+
+  def test_should_parse_object_proxy
+    message = '<return value="123" dataType="object"/>'
+    proxy = @bridge.parse_message_value(Nokogiri::XML(message).root)
+    assert_instance_of Melomel::ObjectProxy, proxy
+    assert_equal 123, proxy.proxy_id
+    assert_equal @bridge, proxy.bridge
+  end
+
+  def test_should_throw_error_parsing_unknown_type
+    message = '<return value="foo" dataType="unknown_type"/>'
+    assert_raises Melomel::UnrecognizedTypeError do
+      @bridge.parse_message_value(Nokogiri::XML(message).root)
+    end
+  end
+
+
+  #############################################################################
+  #
+  # Message Formatting
+  #
+  #############################################################################
+
+  def test_should_format_nil
+    xml = Nokogiri::XML('<root/>').root
+    @bridge.format_message_value(xml, nil)
+    assert_equal '<root dataType="null"/>', xml.to_s
+  end
+  
+  def test_should_format_integer
+    xml = Nokogiri::XML('<root/>').root
+    @bridge.format_message_value(xml, 12)
+    assert_equal '<root value="12" dataType="int"/>', xml.to_s
+  end
+  
+  def should_format_float
+    xml = Nokogiri::XML('<root/>').root
+    @bridge.format_message_value(xml, 100.12)
+    assert_equal '<root value="100.12" dataType="float"/>', xml.to_s
+  end
+
+  def test_should_format_boolean_true
+    xml = Nokogiri::XML('<root/>').root
+    @bridge.format_message_value(xml, true)
+    assert_equal '<root value="true" dataType="boolean"/>', xml.to_s
+  end
+
+  def test_should_format_boolean_false
+    xml = Nokogiri::XML('<root/>').root
+    @bridge.format_message_value(xml, false)
+    assert_equal '<root value="false" dataType="boolean"/>', xml.to_s
+  end
+
+  def test_should_format_string
+    xml = Nokogiri::XML('<root/>').root
+    @bridge.format_message_value(xml, 'foo')
+    assert_equal '<root value="foo" dataType="string"/>', xml.to_s
+  end
+
+  def test_should_format_object
+    proxy = Melomel::ObjectProxy.new(@bridge, 123)
+    xml = Nokogiri::XML('<root/>').root
+    @bridge.format_message_value(xml, proxy)
+    assert_equal '<root value="123" dataType="object"/>', xml.to_s
+  end
+end

data/test/test_object_proxy.rb

@@ -0,0 +1,48 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), *%w[helper])
+
+class ObjectProxyTestCase < MiniTest::Unit::TestCase
+  def setup
+    @bridge = mock()
+    @proxy = Melomel::ObjectProxy.new(@bridge, 123)
+  end
+
+  def test_should_delegate_to_bridge_to_retrieve_property
+    @bridge.expects(:get_property).with(123, 'foo')
+    @proxy.get_property('foo')
+  end
+  
+  def test_should_delegate_to_bridge_to_set_property
+    @bridge.expects(:set_property).with(123, 'foo', 'bar')
+    @proxy.set_property('foo', 'bar')
+  end
+  
+  def test_should_delegate_to_bridge_to_invoke_method
+    @bridge.expects(:invoke_method).with(123, 'foo', 'bar', 'baz')
+    @proxy.invoke_method('foo', 'bar', 'baz')
+  end
+  
+  def test_should_alias_invoke_to_invoke_method
+    @bridge.expects(:invoke_method).with(123, 'foo')
+    @proxy.invoke('foo')
+  end
+  
+  def test_should_alias_accessors_to_get_property_method
+    @proxy.expects(:get_property).with('foo')
+    @proxy.foo
+  end
+  
+  def test_should_alias_mutators_to_set_property_method
+    @proxy.expects(:set_property).with('foo', 'bar')
+    @proxy.foo = 'bar'
+  end
+  
+  def test_should_alias_methods_with_arguments_to_invoke_method
+    @proxy.expects(:invoke_method).with('foo', 'bar', 'baz')
+    @proxy.foo('bar', 'baz')
+  end
+  
+  def test_should_alias_methods_ending_in_bang_to_invoke_method
+    @proxy.expects(:invoke_method).with('foo')
+    @proxy.foo!()
+  end
+end

data/test/test_ui.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), *%w[helper])
+
+class IntegrationTestCase < RunnerTestCase
+  def setup
+    start_runner
+    Melomel.connect()
+  end
+
+  def teardown
+    stop_runner
+  end
+
+  def test_should_find_list_of_labels_named_foo
+    labels = Melomel::UI.find_all('spark.components.Label', :name => 'foo')
+    assert_equal 3, labels.length
+  end
+
+  def should_find_text_input
+    text_input = Melomel::UI.find('spark.components.TextInput', :id => 'nameTextInput')
+    assert_equal 'nameTextField', text_input.name
+  end
+  
+
+  def test_should_click_button
+    button = Melomel::UI.find('spark.components.Button', :id => 'clickButton')
+    label = Melomel::UI.find('spark.components.Label', :id => 'clickLabel')
+    Melomel::UI.click(button)
+    assert_equal 'Hello!', label.text
+  end
+
+  def test_should_double_click_the_button
+    button = Melomel::UI.find('spark.components.Button', :id => 'doubleClickButton')
+    label = Melomel::UI.find('spark.components.Label', :id => 'doubleClickLabel')
+    Melomel::UI.double_click(button)
+    assert_equal 'Hello Hello!', label.text
+  end
+
+
+  def test_should_press_key_down
+    text_input = Melomel::UI.find('spark.components.TextInput', :id => 'keyDownTextInput')
+    label = Melomel::UI.find('spark.components.Label', :id => 'keyDownLabel')
+    Melomel::UI.key_down(text_input, 'a')
+    assert_equal 'a', label.text
+  end
+
+  def test_should_release_key_up
+    text_input = Melomel::UI.find('spark.components.TextInput', :id => 'keyUpTextInput')
+    label = Melomel::UI.find('spark.components.Label', :id => 'keyUpLabel')
+    Melomel::UI.key_up(text_input, 'b')
+    assert_equal 'b', label.text
+  end
+
+  def test_should_press_key
+    text_input = Melomel::UI.find('spark.components.TextInput', :id => 'keyPressTextInput')
+    label = Melomel::UI.find('spark.components.Label', :id => 'keyPressLabel')
+    Melomel::UI.key_press(text_input, 'a')
+    assert_equal 'du', label.text
+  end
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification 
+name: melomel
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Ben Johnson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-26 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 4
+        - 3
+        version: 1.4.3
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 7
+        - 0
+        version: 1.7.0
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 9
+        - 8
+        version: 0.9.8
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+description: Melomel allows Rubyist to communicate with Flash and Flex applications easily
+email: 
+- benbjohnson@yahoo.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/melomel/bridge/messaging.rb
+- lib/melomel/bridge/ui.rb
+- lib/melomel/bridge.rb
+- lib/melomel/object_proxy.rb
+- lib/melomel/ui.rb
+- lib/melomel/version.rb
+- lib/melomel.rb
+- LICENSE
+- README.md
+- CHANGELOG.md
+- test/helper.rb
+- test/test_bridge.rb
+- test/test_integration.rb
+- test/test_messaging.rb
+- test/test_object_proxy.rb
+- test/test_ui.rb
+has_rdoc: true
+homepage: http://github.com/benbjohnson/melomel.rb
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A Ruby interface to Melomel
+test_files: 
+- test/helper.rb
+- test/test_bridge.rb
+- test/test_integration.rb
+- test/test_messaging.rb
+- test/test_object_proxy.rb
+- test/test_ui.rb