swxruby 0.7

data/lib/swxruby.rb

@@ -0,0 +1,6 @@
+$:.unshift File.dirname(__FILE__)
+$:.unshift File.join(File.dirname(__FILE__), 'swxruby')
+class SwxRuby
+  VERSION = '0.7'
+end
+require 'swx_gateway'

data/lib/swxruby/bytecode_converter.rb

@@ -0,0 +1,139 @@
+require 'core_extensions'
+require 'date'
+require 'helper_module'
+
+class BytecodeConverter
+	include HelperMethods
+  class << self
+	  NULL_TERMINATOR = '00'
+	
+	  def convert(data)
+	    conversion_method = "#{data.class.to_s.downcase}_to_bytecode"
+	    
+	    if respond_to?(conversion_method)
+	      send(conversion_method, data)
+	    else
+				# Convert the object to a hash of its instance variables 
+				object_hash = data.instance_values
+				
+				if object_hash.empty?
+					raise StandardError, "#{data.class} is an unhandled data type."
+				else
+		      hash_to_bytecode(object_hash)
+				end
+	    end
+	  end
+	
+	  protected
+		# = Data Type Conversion Methods
+		def complex_data_structure_to_bytecode(data) #:nodoc#
+			bytecode = []
+			
+			# Keeps track of bytecode when recursing into nested data structures
+			stack = []
+
+			# Add the bytecode to initialize the data structure
+			bytecode.push(data.is_a?(Array) ? ActionCodes::INIT_ARRAY : ActionCodes::INIT_OBJECT)
+
+			# Add the length of the data structure to the bytecode
+			bytecode.push integer_to_bytecode(data.length)
+			
+			# Convert each element in the data structure to bytecode
+			data.each do |element|
+				
+        # assume we're not iterating into a recursive data structure
+        complex_data_structure = false
+        
+				# if we're converting a hash, then convert the hash's value
+				if data.is_a?(Hash)
+  				value_bytecode = convert(element[1]) 
+  				# if we just converted an array or a hash, set complex_data_structure to true
+  				complex_data_structure = true if value_bytecode.concludes_with?(ActionCodes::INIT_OBJECT, ActionCodes::INIT_ARRAY)
+  				# set the element local variable to the key of the hash
+					element = element[0]
+				end
+				
+				# element will always contain something (whether iterating over a hash or an array)
+				element_bytecode = convert(element)
+				# if we just converted an array or a hash, set complex_data_structure to true
+				complex_data_structure = true if element_bytecode.concludes_with?(ActionCodes::INIT_OBJECT, ActionCodes::INIT_ARRAY)
+
+        # Create a push of the current bytecode, if
+					 # we recursed into a complex data structure
+					 #									 		 or we're approaching the 65535 byte limit that can be stored in a single push. 
+        if (complex_data_structure || calculate_bytecode_length(bytecode) > 65518)
+        
+          # If we haven't written any bytecode into the local
+          # buffer yet (if it's empty), or all the data is already pushed, skip writing the push statement
+          bytecode.push generate_push_statement(bytecode) unless bytecode.empty? || bytecode.last.begins_with?('96')
+          
+          # Store current instruction on the stack (SWF bytecode is stored in reverse, so we reverse it here)
+          stack.push bytecode.reverse.join
+          
+          # Reset the bytecode
+          bytecode = []
+        end
+        
+        # value_bytecode will be nil unless we converted a Hash
+				bytecode.push value_bytecode unless value_bytecode.nil?
+
+				bytecode.push element_bytecode
+			end
+
+      # If we haven't written any bytecode into the local
+			# buffer yet (if it's empty), or all the data is already pushed, skip writing the push statement
+      bytecode.push generate_push_statement(bytecode) unless bytecode.empty? || bytecode.last.begins_with?('96')
+			
+			# Add the bytecode to the local stack variable (SWF bytecode is stored in reverse, so we reverse it here)
+			stack.push bytecode.reverse.join
+			
+			# Join the stack array into a string and return it (SWF bytecode is stored in reverse, so we reverse it here)
+			stack.reverse.join
+		end
+	  alias array_to_bytecode complex_data_structure_to_bytecode
+    alias hash_to_bytecode complex_data_structure_to_bytecode
+	  
+    def date_to_bytecode(date) #:nodoc#
+      # Format: 2006-09-14
+      string_to_bytecode(date.strftime('%Y-%m-%d'))
+    end
+  
+    def datetime_to_bytecode(datetime) #:nodoc#
+      # Format: 2006-09-14 02:21:10
+			string_to_bytecode(datetime.strftime('%Y-%m-%d %I:%M:%S'))
+    end
+  
+    def falseclass_to_bytecode(*args) #:nodoc#
+      DataTypeCodes::BOOLEAN + '00'
+    end
+  
+		def float_to_bytecode(float) #:nodoc#
+			hex = []
+			[float].pack('E').each_byte { |byte| hex << '%02X' % byte }
+															# Aral did this in SWX PHP, so I'm doing it here
+			DataTypeCodes::FLOAT + (hex[4..-1] + hex[0..3]).join
+		end
+	
+		def integer_to_bytecode(integer) #:nodoc#
+			DataTypeCodes::INTEGER + integer_to_hexadecimal(integer, 4)
+		end
+		alias bignum_to_bytecode integer_to_bytecode
+		alias fixnum_to_bytecode integer_to_bytecode
+				
+		def nilclass_to_bytecode(*args) #:nodoc#
+		  '02'
+		end
+		
+		def string_to_bytecode(string) #:nodoc#
+	    DataTypeCodes::STRING + string.unpack('H*').join.upcase + NULL_TERMINATOR
+	  end
+	  
+    def symbol_to_bytecode(symbol)
+      string_to_bytecode(symbol.to_s)
+    end
+	  
+	  def trueclass_to_bytecode(*args) #:nodoc#
+      DataTypeCodes::BOOLEAN + '01'
+	  end
+	end
+end

data/lib/swxruby/core_extensions.rb

@@ -0,0 +1,41 @@
+# = Core Extensions
+class Array
+  def begins_with?(string)
+    self.join.begins_with?(string)
+  end
+end
+
+class Object
+	# Taken from ActiveRecord
+	def instance_values
+    instance_variables.inject({}) do |values, name|
+      values[name[1..-1]] = instance_variable_get(name)
+      values
+    end
+  end
+end
+
+class String
+  def begins_with?(string)
+    self[0..string.length-1] == string
+  end
+
+  def concludes_with?(*strings)
+    strings.any? { |string| self[-(string.length)..-1] == string }
+  end
+  
+	def hex_to_ascii
+		hex = self.gsub(' ', '')
+		[hex].pack('H*')
+	end
+	
+	# Taken from Rails' Inflector module
+	def underscore
+	  self.to_s.gsub(/::/, '/').
+	    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+	    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+	    tr("-", "_").
+	    downcase
+	end
+end
+

data/lib/swxruby/helper_module.rb

@@ -0,0 +1,72 @@
+require 'core_extensions'
+
+module DataTypeCodes
+   BOOLEAN = '05'
+   FLOAT   = '06'
+   INTEGER = '07'
+   NULL    = '02'
+   STRING  = '00'
+end
+
+module ActionCodes
+	DO_ACTION = '3F03'
+	END_SWF = '0000'
+	INIT_ARRAY = '42'
+	INIT_OBJECT = '43'
+	PUSH = '96LLLL'
+	SET_VARIABLE = '1D'  # 00
+	SHOW_FRAME = '4000'
+end
+
+module HelperMethods
+	module ClassMethods
+		def calculate_bytecode_length(bytecode)
+			# Calculate bytecode length *without* counting the init array or init object action
+			bytecode.join.sub(/^(#{ActionCodes::INIT_ARRAY}|#{ActionCodes::INIT_OBJECT})/, '').length/2
+		end
+
+		def generate_push_statement(bytecode)
+			unpushed_data = []
+			# Iterate over the bytecode array in reverse and add all of the unpushed
+			# data to 'unpushed_data'
+			bytecode.reverse_each do |bytecode_chunk|
+				if bytecode_chunk.begins_with?('96') || bytecode_chunk.begins_with?('1D') then break else unpushed_data << bytecode_chunk end
+			end
+			
+			# Since we iterated over the bytecode in reverse, unpushed_data is reversed, so 
+			# reverse it again before passing it into #calculate_bytecode_length
+			bytecode_length = calculate_bytecode_length(unpushed_data.reverse)
+			
+			 # TODO: Replace with constant
+			'96' + integer_to_hexadecimal(bytecode_length, 2)
+		end
+		
+		def integer_to_hexadecimal(integer, number_of_bytes=1)
+			make_little_endian("%0#{number_of_bytes*2}X" % integer)
+		end
+
+		def make_little_endian(hex_string)
+			# split into an array of string pairs
+			# reverse the array and join back into a string
+			pad_string_to_byte_boundary(hex_string).scan(/../).reverse.join
+		end
+
+		def pad_string_to_byte_boundary(hex_string)
+			hex_string += '0' if hex_string.length % 2 == 1
+			hex_string
+		end
+		
+		# Returns a string with the length of the passed hex string in bytes
+		# padded to display in 'number_of_bytes' bytes.
+		def string_length_in_bytes_hex(string, number_of_bytes)
+																										 # Divide length in chars by 2 to get length in bytes
+			bytecode_length_in_hex = integer_to_hexadecimal(string.length/2, number_of_bytes)
+		end
+	end
+	
+	extend ClassMethods
+	
+	def self.included(receiver)
+		receiver.extend(ClassMethods)
+	end
+end

data/lib/swxruby/rails_integration/render_decorator.rb

@@ -0,0 +1,20 @@
+require 'swx_assembler'
+require 'swx_gateway'
+
+ActionController::Base.class_eval do
+	def render_with_swx(options = nil, &block)
+		if options.is_a?(Hash) && options.keys.include?(:swx)
+			swf_bytecode = SwxAssembler.write_swf(
+								       options[:swx], 
+											 params[:debug], 
+											 SwxGateway.swx_config['compression_level'], 
+											 params[:url], 
+											 SwxGateway.swx_config['allow_domain']
+										 )
+			send_data(swf_bytecode, :type => 'application/swf', :filename => 'data.swf')
+		else
+			render_without_swx(options, &block)
+		end
+	end
+	alias_method_chain :render, :swx
+end

data/lib/swxruby/rails_integration/swx.yml

@@ -0,0 +1,18 @@
+# Service Path: Put your service classes in this folder.
+# Is relative to RAILS_ROOT
+services_path: app/services
+
+# Allow any domain to access the data SWFs from the SWX gateway? 
+# If you set this to false, you will only be able to call the 
+# SWX gateway from SWFs that reside on exactly the same domain
+# (not even subdomains are allowed.)
+#
+# TODO: Allow user to specify a domain (or domains) to allow by 
+# providing URLs.
+allow_domain: true
+
+# How much to compress the returned SWF files. Values range from
+# 0 (no compression) to 9 (maximum compression). The default 
+# compression level is 4. Higher levels of compression may result in
+# smaller SWF files but will take longer to process.
+compression_level: 4

data/lib/swxruby/rails_integration/swx_controller.rb

@@ -0,0 +1,6 @@
+class SwxController < ApplicationController
+  def gateway
+    # request handler takes in the params hash 
+		send_data(SwxGateway.process(params), :type => 'application/swf', :filename => 'data.swf')
+  end
+end

data/lib/swxruby/services/arithmetic.rb

@@ -0,0 +1,9 @@
+class Arithmetic
+	def addition(first, second)
+		first + second
+	end
+
+	def multiply(first, second)
+		first * second
+	end
+end

data/lib/swxruby/services/discovery_service.rb

@@ -0,0 +1,3 @@
+class DiscoveryService
+	
+end

data/lib/swxruby/services/hello_world.rb

@@ -0,0 +1,7 @@
+# Class and method names follow standard Ruby conventions
+class HelloWorld
+	# Service class methods are instance methods.
+	def just_say_the_words
+		'Hello World!'
+	end
+end

data/lib/swxruby/services/simple.rb

@@ -0,0 +1,5 @@
+class Simple
+	def add_numbers(first, second)
+		first + second
+	end
+end

data/lib/swxruby/services/test_data_types.rb

@@ -0,0 +1,94 @@
+class TestTO
+	def initialize
+		@prop1 = 'A string'
+		@prop2 = 42
+	end
+end
+
+###
+ # Data type test service. Run the TestDataTypes.fla to run through all these tests using SWX RPC. 
+ #
+ # @package default
+ # @author Aral Balkan
+ ###
+class TestDataTypes
+	###
+	 # Returns the boolean true.
+	 # @author Aral Balkan
+	 ###
+	def test_true
+		true
+	end
+	
+	###
+	 # Returns the boolean false.
+	 # @author Aral Balkan
+	 ###
+	def test_false
+		false
+	end
+	
+	###
+	 # Returns the array ['It', 'works']
+	 # @author Aral Balkan
+	 ###
+	def test_array
+		%w(It works)
+	end
+	
+	###
+	 # Returns the nested array ['It', ['also'], 'works]
+	 # @author Aral Balkan
+	 ###
+	def test_nested_array
+		['It', ['also'], 'works']
+	end
+	
+	###
+	 # Returns the integer 42.
+	 # @author Aral Balkan
+	 ###
+	def test_integer
+		42
+	end
+	
+	###
+	 # Returns the float 42.12345.
+	 # @author Aral Balkan
+	 ###
+	def test_float
+		42.12345
+	end
+	
+	###
+	 # Returns the string "It works!"
+	 # @author Aral Balkan
+	 ###
+	def test_string
+		"It works!"
+	end
+	
+	###
+	 # Returns the associative array ['it' => 'works', 'number' => 42]
+	 # @author Aral Balkan
+	 ###
+	def test_associative_array
+		{'it' => 'works', 'number' => 42}
+	end
+
+	###
+	 # Returns an instance of the TestTO class with properties prop1: "A string" and prop2: 42.
+	 # @author Aral Balkan
+	 ###
+	def test_object
+		TestTO.new
+	end
+	
+	###
+	 # Returns null.
+	 # @author Aral Balkan
+	 ###
+	def test_null
+		nil
+	end
+end

data/lib/swxruby/swx_assembler.rb

@@ -0,0 +1,138 @@
+require 'bytecode_converter'
+require 'helper_module'
+require 'uri/common.rb'
+require 'zlib'
+
+class SwxAssembler
+	include HelperMethods
+	
+	# Header - FCS (uncompressed), version Flash 6
+	UNCOMPRESSED_SWF = '46'
+	COMPRESSED_SWF = '43'
+	HEADER = '575306LLLLLLLL300A00A0000101004302FFFFFF'
+
+	# Misc
+	NULL_TERMINATOR = '00'
+
+	# Allow domain (*)
+	ALLOW_DOMAIN = '960900005F706172656E74001C960600005F75726C004E960D0007010000000053797374656D001C960A00007365637572697479004E960D0000616C6C6F77446F6D61696E005217'
+	SYSTEM_ALLOW_DOMAIN = '07010000000053797374656D001C960A00007365637572697479004E960D0000616C6C6F77446F6D61696E005217'
+
+	# Debug SWX bytecode. Creates a local connection to the SWX Debugger front-end.)
+	DEBUG_START = '883C000700726573756C74006C63004C6F63616C436F6E6E656374696F6E005F737778446562756767657200636F6E6E6563740064656275670073656E6400'
+	DEBUG_END = '960D0008010600000000000000000802403C9609000803070100000008011C9602000804521796020008001C960500070100000042960B0008050803070300000008011C96020008065217'
+	
+	class << self
+		def allow_domain_bytecode(allow_domain_url = '')
+  		if (allow_domain_url.nil? || allow_domain_url.empty?)
+  			# No URL passed -- possibly called by legacy code, use the old _parent._url version.
+        # error_log('[SWX] INFO: No URL passed from client. Defaulting to old behavior. You must call System.security.allowDomain on the dataHolder for cross domain data loading to work.');
+  			ALLOW_DOMAIN
+		  else
+				# Firefox/Flash (at least, and tested only on a Mac), sends 
+				# file:/// (three slashses) in the URI and that fails the validation
+				# so replacing that with two slashes instead.
+				allow_domain_url.gsub!('///', '//')
+    		# URL is passed, write that into the returned code
+    		allow_domain_bytecode = BytecodeConverter.convert(URI.unescape(allow_domain_url))
+				
+    		# The -13 is to accomodate the other elements being pushed to the 
+    		# stack in the hard-coded part of the bytecode.
+    		allow_domain_bytecode_length_dec = allow_domain_bytecode.length/2 + 13
+
+    		allow_domain_bytecode_length = integer_to_hexadecimal(allow_domain_bytecode_length_dec, 2);
+    		allow_domain_bytecode = '96' + allow_domain_bytecode_length + allow_domain_bytecode + SYSTEM_ALLOW_DOMAIN;
+				allow_domain_bytecode
+  		end
+  	end
+
+	  def compress_swx_file(swx_file, compression_level)
+	    # The first eight bytes of a compressed SWF file are left uncompressed
+      swx_file.slice!(0...8) + Zlib::Deflate.deflate(swx_file, compression_level)
+	  end
+	
+		def generate_data_bytecode(data)
+			data_bytecode = []
+			
+			# Add a flag to the beginning of the bytecode that tells Flash we're setting a variable (result)
+			data_bytecode.push ActionCodes::SET_VARIABLE
+						
+			# Convert the data (payload) to bytecode
+			data_bytecode.push BytecodeConverter.convert(data)
+			
+			# Generate a push tag if the data was not an Array or a Hash
+			data_bytecode.push generate_push_statement(data_bytecode) unless data.is_a?(Array) || data.is_a?(Hash)
+			
+			# Add the 'result' variable name -- either
+			# using the constant table if in debug mode
+			# or as a regular string otherwise
+      if @debug
+				data_bytecode.push '9602000800'
+			else
+				data_bytecode.push '96080000726573756C7400'
+			end
+			
+			# (SWF bytecode is stored in reverse, so we reverse it here)
+      data_bytecode.reverse.join
+		end
+	  
+	  def generate_swx_bytecode(data)
+	    # Create the DoAction tag
+			do_action_block = []
+			
+			# Wrap the data bytecode in debug flags if debugging is turned on
+			do_action_block.push DEBUG_START if @debug
+			
+			# Generate bytecode for the data (payload)
+			do_action_block.push generate_data_bytecode(data)
+      
+			# Allow domain? If so add allow domain statement to the SWF
+      if (@allow_domain)
+        do_action_block.push allow_domain_bytecode(@allow_domain_url)
+      end
+			
+			# Wrap the data bytecode in debug flags if debugging is turned on
+			do_action_block.push DEBUG_END if @debug
+
+      # Calculate the size of the do_action block
+			do_action_block_size_in_bytes = string_length_in_bytes_hex(do_action_block.join, 4)
+			# Add the appropriate flags to the do_action block and concat the finished do_action block into a string
+			do_action_block_string = ActionCodes::DO_ACTION + do_action_block_size_in_bytes + do_action_block.join
+
+			# Create the rest of the SWF
+			header_type = if @compression_level > 0 then COMPRESSED_SWF else UNCOMPRESSED_SWF end
+
+			swf = header_type + HEADER + do_action_block_string + ActionCodes::SHOW_FRAME + ActionCodes::END_SWF
+			swf_size_in_bytes = string_length_in_bytes_hex(swf, 4)
+           
+			# Replace length placeholder (from HEADER constant) with actual bytecode length
+			swf.sub('LLLLLLLL', swf_size_in_bytes)
+	  end
+	  
+		def write_swf(data, debug=false, compression_level=4, allow_domain_url='', allow_domain=true)
+		  # Set up SwfAssembler state
+		  @debug = debug
+		  @compression_level = compression_level
+		  @allow_domain_url = allow_domain_url
+			@allow_domain = allow_domain
+
+      swx_bytecode = generate_swx_bytecode(data)
+
+			# Convert the bytecode string to ASCII file format
+      swx_file = swx_bytecode.hex_to_ascii
+
+      # Compress the file if compression is turned on
+      swx_file = compress_swx_file(swx_file, compression_level) if compression_level > 0
+
+      # ====================================
+      # = TODO: Remove this before release =
+      # ====================================
+      # Write the file (for manual 'loadMovie' testing in Flash)
+      # File.open('/Users/Jed/Development/Libraries/rSWX/testing/flash/rswx_data.swx', 'w+') do |file|
+      #   file << swx_file
+      # end      
+
+      swx_file
+		end
+	end
+end