kolach-melomel 0.6.4

data/CHANGELOG

@@ -0,0 +1,35 @@
+v0.6.4
+* added `I should see no data in the "([^"]*)" data grid'
+
+v0.6.3
+* minor changes in working with data grids
+
+v0.6.2 contribution
+* added Advanced Data Grid class support for grid steps
+* minor issue fixed: nil.trim!
+* added `should not see' for text label
+
+v0.6.0
+* Added wait interface.
+* Added focus to components in Cucumber steps.
+
+v0.5.0
+* Added Cucumber support.
+
+v0.4.0
+* Added error serialization with stack tracing from Flash to Ruby.
+
+
+v0.3.1
+* Removed requirement for adding a bang to the end of no-arg methods.
+
+v0.3.0
+* Added `Melomel.invoke_function()` for package level functions invocation. (Nikita Dudnik)
+
+v0.2.0
+* Moved `Melomel::UI` methods into `Melomel`.
+* Changed Flex build from `ant compile` to `ant build`.
+* Made `build` the default ant target.
+
+v0.1.0
+* Initial alpha version.

data/README.md

@@ -0,0 +1,58 @@
+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 site:
+
+http://melomel.info
+
+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.
+
+
+## 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. First compile the Flex application and then run the test suite with
+`rake`:
+
+	ant
+	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.rb

@@ -0,0 +1,48 @@
+$:.unshift(File.dirname(__FILE__)) unless $:.index(File.dirname(__FILE__))
+
+require 'object'
+require 'melomel/bridge'
+require 'melomel/date'
+require 'melomel/error'
+require 'melomel/flex'
+require 'melomel/object_proxy'
+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
+
+    def method_missing(method, *args)
+      @bridge.__send__(method.to_sym, *args)
+    end
+    
+    # Retrieves a reference to a class
+    def get_class(*args)
+      @bridge.get_class(*args)
+    end
+
+    # Creates an object in the virtual machine.
+    def create_object(class_name)
+      @bridge.create_object(class_name)
+    end
+    
+    # Invokes package level function
+    def invoke_function(function, *args)
+      @bridge.invoke_function(function, *args)
+    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, 0)
+      socket.flush()
+      socket.close()
+    end
+  end
+end

data/lib/melomel/bridge/messaging.rb

@@ -0,0 +1,252 @@
+require 'nokogiri'
+
+# These add-on methods enable the message encoding and decoding.
+module Melomel
+  class Bridge
+    ###########################################################################
+    #
+    # Basic Messages
+    #
+    ###########################################################################
+
+    # Creates an object in the Flash virtual machine and returns the reference
+    # to it.
+    #
+    # class_name - The name of the class to instantiate.
+    #
+    # Returns an instance of the class if the class is found. Otherwise, nil.
+    def create_object(class_name)
+      send_create_object(class_name, false)
+    end
+
+    # Same as `create_object` except that an error is thrown if the class is
+    # not found.
+    def create_object!(class_name)
+      send_create_object(class_name, true)
+    end
+
+    # Retrieves a reference to a class in the Flash virtual machine.
+    #
+    # class_name - The name of the class to retrieve a reference to.
+    #
+    # Returns a reference to the class if it exists. Otherwise, nil.
+    def get_class(class_name)
+      send_get_class(class_name, false)
+    end
+
+    # Same as `get_class` except that an error is thrown if the class is not
+    # found.
+    def get_class!(class_name)
+      send_get_class(class_name, true)
+    end
+
+    # Retrieves a property of an object in the Flash virtual machine
+    #
+    # proxy_id - The identifier for the object proxy.
+    # property - The name of the property to access.
+    # 
+    # Returns the value of the property if it exists. Otherwise, nil.
+    def get_property(proxy_id, property)
+      send_get_property(proxy_id, property, false)
+    end
+
+    # Same as `get_property` except that an error is thrown if the property
+    # does not exist.
+    def get_property!(proxy_id, property)
+      send_get_property(proxy_id, property, true)
+    end
+
+    # Sets a property on an object in the Flash virtual machine
+    #
+    # proxy_id - The identifier of the object proxy.
+    # property - The name of the property to mutate.
+    # value    - The value to set the property to.
+    #
+    # Returns the value of the property after being set.
+    def set_property(proxy_id, property, value)
+      send_set_property(proxy_id, property, value, false)
+    end
+
+    # Same as `set_property` except that an error is thrown if the property
+    # does not exist.
+    def set_property!(proxy_id, property, value)
+      send_set_property(proxy_id, property, value, true)
+    end
+
+    # Invokes a method on an object in the Flash virtual machine
+    #
+    # proxy_id    - The identifier of the object proxy.
+    # method_name - The name of the method to invoke.
+    # *args       - List of arguments passed to the method.
+    #
+    # Returns the value returned from the Flash method.
+    def invoke_method(proxy_id, method_name, *args)
+      send_invoke_method(proxy_id, method_name, args, false)
+    end
+    
+    # Same as `invoke_method` except that an error is thrown if the method
+    # does not exist.
+    def invoke_method!(proxy_id, method_name, *args)
+      send_invoke_method(proxy_id, method_name, args, true)
+    end
+    
+    # Invokes a package level function in the Flash virtual machine
+    # 
+    # function_name - The fully qualified name of the function to invoke.
+    # *args         - List of arguments passed to the function.
+    #
+    # Returns the return value of the Flash function.
+    def invoke_function(function_name, *args)
+      send_invoke_function(function_name, args, false)
+    end
+
+    # Same as `invoke_function` except that an error is thrown if the method
+    # does not exist.
+    def invoke_function!(function_name, *args)
+      send_invoke_function(function_name, args, true)
+    end
+
+
+    ###########################################################################
+    #
+    # Utility Methods
+    #
+    ###########################################################################
+
+    # Formats a Ruby value into an XML message
+    def format_message_value(xml, value)
+      # Automatically convert simple objects to proxies.
+      value = value.to_object_proxy(self) unless value.nil?
+      
+      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)
+      name = xml.name()
+      
+      # If we receive an error back then raise it in the Ruby VM.
+      if name == 'error'
+        stack_trace_xml = xml.at_xpath('stack-trace')
+        object      = Melomel::ObjectProxy.new(self, xml['proxyId'].to_i)
+        error_id    = xml['errorId'].to_i
+        message     = xml['message']
+        name        = xml['name']
+        stack_trace = stack_trace_xml ? stack_trace_xml.to_str : nil
+        $stderr.puts(stack_trace)
+        raise Melomel::Error.new(object, error_id, message, name, stack_trace), message
+
+      # Otherwise we have a return value so we should parse it.
+      else
+        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
+    
+
+    ###########################################################################
+    #
+    # Private Methods
+    #
+    ###########################################################################
+
+    private
+    
+    # Creates an object in the Flash virtual machine and returns the reference
+    # to it.
+    def send_create_object(class_name, throwable=true)
+      send("<create class=\"#{class_name}\" throwable=\"#{throwable}\"/>")
+      parse_message_value(Nokogiri::XML(receive()).root)
+    end
+
+    # Retrieves a reference to a class in the Flash virtual machine.
+    def send_get_class(class_name, throwable=true)
+      send("<get-class name=\"#{class_name}\" throwable=\"#{throwable}\"/>")
+      parse_message_value(Nokogiri::XML(receive()).root)
+    end
+
+    # Retrieves a property of an object in the Flash virtual machine
+    def send_get_property(proxy_id, property, throwable)
+      send("<get object=\"#{proxy_id}\" property=\"#{property}\" throwable=\"#{throwable}\"/>")
+      parse_message_value(Nokogiri::XML(receive()).root)
+    end
+
+    # Sets a property on an object in the Flash virtual machine
+    def send_set_property(proxy_id, property, value, throwable)
+      # Create message and format value to set
+      xml = Nokogiri::XML("<set object=\"#{proxy_id}\" property=\"#{property}\" throwable=\"#{throwable}\"><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 send_invoke_method(proxy_id, method_name, args, throwable)
+      xml = Nokogiri::XML("<invoke object=\"#{proxy_id}\" method=\"#{method_name}\" throwable=\"#{throwable}\"><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
+    
+    # Invokes a package level function in the Flash virtual machine
+    def send_invoke_function(function_name, args, throwable)
+      xml = Nokogiri::XML("<invoke-function name=\"#{function_name}\" throwable=\"#{throwable}\"><args/></invoke>")
+
+      # Loop over and add arguments to call
+      args_node = xml.at_xpath('invoke-function/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
+  end
+end