swxruby 0.7

data/lib/swxruby/swx_gateway.rb

@@ -0,0 +1,104 @@
+require 'json'
+require 'swx_assembler'
+
+# Create a namespace (sandbox) for SWX service classes; ensures we don't get 
+# any bored twelve year-olds trying to call Kernel#system using our gateway
+# (they would instead be calling SwxServiceClasses::Kernel#system)
+module SwxServiceClasses; end
+
+class SwxGateway
+  class << self
+		attr_accessor :app_root, :swx_config
+		
+		# Eval all files in the services_path into the SwxServiceClasses namespace
+		def init_service_classes
+			Dir.glob(File.join(app_root, swx_config['services_path'], './**/*.rb'))	do |filename| 
+				# Load service class into SwxServiceClasses namespace. 
+				SwxServiceClasses.module_eval(File.read(filename))
+			end
+			true
+		end
+		
+		# Convert strings containing 'null' to nil. Null in Flash is equivalent to nil in Ruby.
+		def nillify_nulls(args_array)
+			# Convert all strings containing 'null' to nil
+			args_array.collect! { |arg| if arg == 'null' then nil else arg end }
+			# Return nil if the args array contained only 'null' strings
+			if args_array.compact.empty? then nil else args_array end
+		end
+		
+		# The entry point for SWX request processing. Takes a hash of +params+ and goes to work generating SWX bytecode. 
+    # 
+		# Special note: Contrary to Ruby convention, keys in the +params+ hash are camelCase (instead of underscored). This 
+		# is to maintain compatibility with the SWX AS library which sends request parameters 
+		# using camelCase (ActionScript's variable naming convention).
+    # 
+		# ==== Params
+		# * <tt>:args</tt> --  JSON string of arguments (converted to a Ruby object and passed to the specified method of the service class)
+		# * <tt>:debug</tt> -- Boolean. If set to true, the generated SWX file will attempt to establish a local connection the SWX Analyzer when opened in Flash Player.
+		# * <tt>:method</tt> --  specifies the method to be called on the service class. May be either camelCased or underscored (camelCased will be converted to underscored before being called on the service class)
+		# * <tt>:serviceClass</tt> -- specifies the service class 
+		# * <tt>:url</tt> -- (optional) the url of the SWF file making this request. Added to the generated SWX file to skirt cross-domain issues. If not specified, the resulting SWX file allow access from any domain
+    # 
+		# ==== Examples
+	  #   SwxGateway.process(:args => 'Hello World!', :debug => true, :method => 'echo_data', :serviceClass => 'Simple', :url => 'http://myfunkysite/swxconsumer.swf')
+	  #   # => A binary string of SWX bytecode containing the result of +Simple.new#echo_data('Hello World!')+; debugging enabled and allowing access from the specified url
+    #   
+	  #   SwxGateway.process(:args => 'Hello World!', :debug => true, :method => 'echo_data', :serviceClass => 'Simple')
+	  #   # => Same as previous, except allows access from any url
+    #   
+	  #   SwxGateway.process(:args => [1,2], :debug => false, :method => 'addNumbers', :serviceClass => 'Simple', :url => 'http://myfunkysite/swxconsumer.swf')
+	  #   # calls params[:method].underscore
+	  #   # => A binary string of SWX bytecode containing the result of +Simple.new#add_numbers(1, 2)+; no debugging and allowing access from the specified url
+    def process(params)
+      # Set defaults if the SWX gateway isn't configured
+      swx_config ||= {'compression_level' => 4, 'allow_domain' => true}
+      
+			# convert JSON arguments to a Ruby object
+			args = json_to_ruby params[:args]
+			
+      unless args.nil?
+        # Ensure that none of the arguments contain 'undefined'
+  			raise ArgumentError, "The request contained undefined args.\n  serviceClass: #{params[:serviceClass]}\n  method: #{params[:method]}\n  args: #{args.join(', ')}" if args.any? { |argument| argument == 'undefined' }
+				# Convert 'null' strings in args array to nil
+			  args = nillify_nulls(args)
+  		end
+			
+			# Fetch the class constant for the specified service class
+			validate_service_class_name(params[:serviceClass])
+      service_class = class_eval("SwxServiceClasses::#{params[:serviceClass]}")
+
+			# convert camelCased params[:method] to underscored (does nothing if params[:method] is already underscored)
+			# This effectively bridges the gap between ActionScript and Ruby variable/method naming conventions.
+			params[:method] = params[:method].underscore
+
+			# Prevent nefarious use of methods that the service class inherited from Object
+			raise NoMethodError unless (service_class.public_instance_methods - Object.public_instance_methods).include?(params[:method])
+			
+      # Instantiate the service class, call the specified method, and capture the response
+			service_class_response = if args.nil?
+				# No args were passed, so assume the service class' method doesn't take any arguments
+	      service_class.new.send(params[:method])
+			else
+				# Call the service class' method and pass in the arguments (uses an * to pass an array as multiple arguments)
+	      service_class.new.send(params[:method], *args)
+			end
+
+      # convert 'true' and 'false' to real booleans
+      debug_param = params[:debug] == 'true' ? true : false
+      
+      # assemble and return swx file 
+			SwxAssembler.write_swf(service_class_response, debug_param, swx_config['compression_level'], params[:url], swx_config['allow_domain'])
+    end
+    
+    def json_to_ruby(arguments) #:nodoc:
+      JSON.parse arguments unless arguments.nil? || arguments.empty?
+    end
+
+		def validate_service_class_name(service_class) #:nodoc:
+			unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ service_class
+		    raise NameError, "#{service_class.inspect} is not a valid constant name!"
+		  end
+		end
+  end
+end

data/lib/swxruby/version.rb

@@ -0,0 +1,9 @@
+module Swxruby #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 7
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+gem 'rspec'
+require 'spec'
+
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib', 'swxruby')
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib', 'swxruby', 'services')

data/spec/swxruby/bytecode_converter_spec.rb

@@ -0,0 +1,162 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'active_record'
+require 'bytecode_converter'
+require 'date'
+
+describe BytecodeConverter, 'in regard to arrays' do
+	it 'should convert an array of integers to bytecode' do
+		BytecodeConverter.convert([1, 2, 3]).should == '961400070300000007020000000701000000070300000042'
+	end
+
+	it 'should convert an array containing nil values to bytecode' do
+	  BytecodeConverter.convert([1, nil, 3]).should == '9610000703000000020701000000070300000042'
+	end
+
+	it %q(should convert an array of strings to bytecode) do
+		BytecodeConverter.convert(['one', 'two', 'three']).should == '961600007468726565000074776F00006F6E6500070300000042'
+	end
+
+	it %q(should convert an array of mixed datatypes to bytecode) do
+		BytecodeConverter.convert([1, 'two', 3.5]).should == '9618000600000C40000000000074776F000701000000070300000042'
+	end
+
+	it %q(should convert nested arrays to bytecode) do
+		BytecodeConverter.convert([1, ['two', 3.5]]).should == '9613000600000C40000000000074776F00070200000042960A000701000000070200000042'
+	end
+
+	it %q(should convert more nested arrays to bytecode) do
+		BytecodeConverter.convert([[1], 'two', 3.5]).should == '960E000600000C40000000000074776F00960A000701000000070100000042960500070300000042'
+	end
+
+	it %q(should convert an array with nested hashes to bytecode) do
+		BytecodeConverter.convert([1, {'number' => 2}, 3]).should == '9605000703000000961200006E756D626572000702000000070100000043960A000701000000070300000042'
+	end
+
+	it %q(should convert an array with nested hashes with nested arrays to bytecode) do
+		BytecodeConverter.convert([1, {'numbers' => [{'two' => 2}, {'three' => 3}]}, 4]).should == '9605000704000000960900006E756D6265727300961100007468726565000703000000070100000043960F000074776F000702000000070100000043960500070200000042960500070100000043960A000701000000070300000042'
+	end	
+end
+
+describe BytecodeConverter, 'in regard to booleans' do
+	it 'should convert "true" to bytecode' do
+    BytecodeConverter.convert(true).should == '0501'
+  end
+  
+  it 'should convert "false" to bytecode' do
+    BytecodeConverter.convert(false).should == '0500'
+  end
+end
+
+describe BytecodeConverter, 'in regard to custom classes' do
+  it 'should convert the class to a hash by calling CustomClass#instance_values' do
+		@custom_class = mock('MyCustomClass')
+		# BytecodeConverter.should_receive(:convert).with(@custom_class)
+		@custom_class.should_receive(:instance_values).and_return({'it' => 'works'})
+		# BytecodeConverter.should_receive(:convert).with({'it' => 'works'})
+		
+    BytecodeConverter.convert(@custom_class)
+  end
+end
+
+describe BytecodeConverter, 'in regard to datetimes' do
+  it 'should convert a datetime to a string and pass it to BytecodeConverter#string_to_bytecode' do
+    BytecodeConverter.should_receive(:string_to_bytecode).with(an_instance_of(String))
+		BytecodeConverter.convert(DateTime.new(2007, 9, 9, 12, 30))
+  end
+end
+
+describe BytecodeConverter, 'in regard to dates' do
+  it 'should convert a date to a string and pass it to BytecodeConverter#string_to_bytecode' do
+		BytecodeConverter.should_receive(:string_to_bytecode).with(an_instance_of(String))
+		BytecodeConverter.convert(Date.new(2007, 9, 9))
+  end
+end
+
+describe BytecodeConverter, 'in regard to floats' do
+	it 'should convert negative floats to bytecode' do
+	  BytecodeConverter.convert(-0.123456789).should == '06DD9ABFBF5F633937'
+	end
+	
+	it 'should convert floats to bytecode' do
+		BytecodeConverter.convert(1.2).should == '063333F33F33333333'
+	end	
+end
+
+describe BytecodeConverter, 'in regard to hashes' do
+  it %q[should convert a hash with string and integer values to bytecode] do
+    BytecodeConverter.convert({'it' => 'works', 'number' => 42}).should == '961D00006E756D62657200072A0000000069740000776F726B7300070200000043'
+  end
+  
+  it %q[should convert a hash with symbols for keys to bytecode] do
+    BytecodeConverter.convert({:it => 'works', :number => 42}).should == '961D00006E756D62657200072A0000000069740000776F726B7300070200000043'
+  end
+
+  it %q[should convert a hash with nested arrays to bytecode] do
+    BytecodeConverter.convert({'they' => ['really', 'work'], 'numbers' => [1, 2, 3]}).should == '960900006E756D626572730096140007030000000702000000070100000007030000004296060000746865790096130000776F726B00007265616C6C7900070200000042960500070200000043'
+  end
+
+	it 'should convert a hash containing nil values to bytecode' do
+	  BytecodeConverter.convert({'hello' => nil}).should == '960D000068656C6C6F0002070100000043'
+	end
+end
+
+describe BytecodeConverter, 'in regard to integers' do
+	it 'should convert "0" to bytecode' do
+	  BytecodeConverter.convert(0).should == '0700000000'
+	end
+	
+	it 'should convert "1" to bytecode' do
+	  BytecodeConverter.convert(1).should == '0701000000'
+	end
+	
+	it 'should convert "900" to bytecode' do
+    BytecodeConverter.convert(900).should == '0784030000'
+  end
+
+	it 'should convert "16711680" to bytecode' do
+    BytecodeConverter.convert(16711680).should == '070000FF00'
+  end
+
+  it 'should convert "4294967295" to bytecode' do
+    BytecodeConverter.convert(4294967295).should == '07FFFFFFFF'
+  end
+end
+
+describe BytecodeConverter, 'in regard to nil' do
+  it 'should convert "nil" to bytecode' do
+   BytecodeConverter.convert(nil).should == '02'
+  end
+end
+
+describe BytecodeConverter, 'in regard to strings' do
+  it 'should convert "hello" to bytecode' do
+    BytecodeConverter.convert('hello').should == '0068656C6C6F00'
+  end
+  
+  it 'should convert "goodbye" to bytecode' do
+    BytecodeConverter.convert('goodbye').should == '00676F6F6462796500'
+  end
+
+  it 'should convert an empty string to bytecode' do
+    BytecodeConverter.convert('').should == '0000'
+  end
+end
+
+describe BytecodeConverter, 'in regard to symbols' do
+  it 'should convert :hello to bytecode' do
+    BytecodeConverter.convert(:hello).should == '0068656C6C6F00'
+  end
+  
+  it 'should convert :goodbye to bytecode' do
+    BytecodeConverter.convert(:goodbye).should == '00676F6F6462796500'
+  end
+end
+
+
+    
+describe BytecodeConverter, 'in regard to unhandled datatypes' do
+  it 'should raise an exception when asked to convert an unhandled data type' do
+    lambda { BytecodeConverter.convert(/^What about (me)?$/) }.should raise_error(StandardError)
+  end
+end  

data/spec/swxruby/core_extensions_spec.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'core_extensions'
+
+class MyClass
+	def initialize
+		@foo = 'foo'
+		@bar = 'bar'
+	end
+end
+
+describe 'Object extensions' do
+  it '#instance_values should convert an object\'s instance variables to a hash' do
+    MyClass.new.instance_values.should be_an_instance_of(Hash)
+    MyClass.new.instance_values.sort_by { |key, value| value }.should == [['bar', 'bar'], ['foo', 'foo']]
+  end
+end

data/spec/swxruby/rails_integration/render_decorator_spec.rb

@@ -0,0 +1,73 @@
+RSPEC_ON_RAILS_FILE = File.expand_path(File.dirname(__FILE__) + "../../../rspec_on_rails/lib/spec/rails.rb")
+RAILS_ROOT = File.expand_path(File.dirname(__FILE__) + "../../../../../")
+
+if File.exist?(RSPEC_ON_RAILS_FILE)
+	ENV["RAILS_ENV"] = "test"
+	require RAILS_ROOT + "/config/environment"
+	require RSPEC_ON_RAILS_FILE
+
+	Spec::Runner.configure do |config|
+	  config.use_transactional_fixtures = false
+	  config.use_instantiated_fixtures  = false
+	  config.fixture_path = RAILS_ROOT + '/spec/fixtures'
+
+	  # You can declare fixtures for each behaviour like this:
+	  #   describe "...." do
+	  #     fixtures :table_a, :table_b
+	  #
+	  # Alternatively, if you prefer to declare them only once, you can
+	  # do so here, like so ...
+	  #
+	  #   config.global_fixtures = :table_a, :table_b
+	  #
+	  # If you declare global fixtures, be aware that they will be declared
+	  # for all of your examples, even those that don't use them.
+	end
+	
+	
+	$:.unshift File.join(File.dirname(__FILE__), '..', 'lib', 'rails_integration')
+	$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+	require 'rubygems'
+	require 'spec/runner'
+
+	require 'render_decorator'
+	require 'swx_gateway'
+	
+	describe 'Render decorator\'s effect on Rails\' vanilla render method' do
+	  it 'should alias ActionController::Base#render as render_with_swx' do
+	    ActionController::Base.new.should respond_to(:render_with_swx)
+	  end
+	
+		it 'should create ActionController::Base#render_without_swx' do
+		  ActionController::Base.new.should respond_to(:render_without_swx)
+		end
+	end
+	
+	describe '#render_with_swx' do
+		before do
+			@controller = ActionController::Base.new
+		  @controller.stub!(:params).and_return(:debug => 'true', :url => '')
+			@controller.stub!(:send_data)
+			SwxAssembler.stub!(:write_swf).and_return('swx bytecode')
+		end
+		
+		it 'should delegate calls that don\'t contain a :swx key to #render_without_swx' do
+			@controller.should_receive(:render_without_swx)
+			@controller.render(:text => 'not a swx request')
+		end
+		
+	  it 'should utilize SwxAssembler to generate the SWX bytecode' do
+			SwxAssembler.should_receive(:write_swf).with('Jeremiah was a bullfrog.', 'true', SwxGateway.swx_config['compression_level'], '', SwxGateway.swx_config['allow_domain'])
+			@controller.render(:swx => 'Jeremiah was a bullfrog.')
+	  end
+	
+		it 'should stream the generated SWX bytecode back to the user' do
+			@controller.should_receive(:send_data).with('swx bytecode', :type => 'application/swf', :filename => 'data.swf')
+			@controller.render(:swx => 'some data')
+		end
+	end
+else
+	puts 'Not installed as Rails plugin. Skipping Rails integration specifications.'
+end
+
+

data/spec/swxruby/rails_integration/swx_controller_spec.rb

@@ -0,0 +1,5 @@
+describe 'Rails SwxController' do
+  it 'should provide a #gateway action to handle SWX requests' do
+    pending(%q{It's implemented, just not specified yet.})
+  end
+end

data/spec/swxruby/swx_assembler_spec.rb

@@ -0,0 +1,60 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'swx_assembler'
+
+describe SwxAssembler do
+  it 'should assemble a swx file without debugging and without compression' do
+		BytecodeConverter.should_receive(:convert).with(1).once.and_return('0701000000')
+    SwxAssembler.write_swf(1, false, 0).should == File.read(File.join(File.dirname(__FILE__), 'fixtures', 'number_one_no_debug_no_compression.swx'))
+  end
+  
+  it 'should assemble a swx file with debugging and without compression' do
+		BytecodeConverter.should_receive(:convert).with(1).once.and_return('0701000000')
+    SwxAssembler.write_swf(1, true, 0).should == File.read(File.join(File.dirname(__FILE__), 'fixtures', 'number_one_with_debug_no_compression.swx'))
+  end
+  
+	it 'should assemble a swx file without debugging, without compression, and with an arbitrary "allow domain" url' do
+		BytecodeConverter.should_receive(:convert).with('file://Macintosh HD/Users/Jed/Development/Libraries/rSWX/testing/flash/data_testing.swf').once.and_return('0066696C653A2F2F4D6163696E746F73682048442F55736572732F4A65642F446576656C6F706D656E742F4C69627261726965732F725357582F74657374696E672F666C6173682F646174615F74657374696E672E73776600')
+		BytecodeConverter.should_receive(:convert).with(1).once.and_return('0701000000')
+	  SwxAssembler.write_swf(1, false, 0, 'file:///Macintosh HD/Users/Jed/Development/Libraries/rSWX/testing/flash/data_testing.swf').should == File.read(File.join(File.dirname(__FILE__), 'fixtures', 'number_one_no_debug_no_compression_arbitrary_allow_domain.swx'))
+	end
+
+  it 'should assemble a swx file without debugging and with compression' do
+		BytecodeConverter.should_receive(:convert).with(1).once.and_return('0701000000')
+		SwxAssembler.write_swf(1, false, 4).should == File.read(File.join(File.dirname(__FILE__), 'fixtures', 'number_one_no_debug_compression_4.swx'))
+	end
+    
+  it 'should assemble a swx file with debugging and with compression' do
+		BytecodeConverter.should_receive(:convert).with(1).once.and_return('0701000000')
+		SwxAssembler.write_swf(1, true, 4).should == File.read(File.join(File.dirname(__FILE__), 'fixtures', 'number_one_with_debug_compression_4.swx'))
+	end
+end
+
+describe 'SwxAssembler#allow_domain_bytecode' do
+  it 'should generate bytecode to allow an arbitrary url when a url is passed' do
+    SwxAssembler.allow_domain_bytecode('file://Macintosh HD/Users/Jed/Development/Libraries/rSWX/testing/flash/data_testing.swf').should == '9666000066696C653A2F2F4D6163696E746F73682048442F55736572732F4A65642F446576656C6F706D656E742F4C69627261726965732F725357582F74657374696E672F666C6173682F646174615F74657374696E672E7377660007010000000053797374656D001C960A00007365637572697479004E960D0000616C6C6F77446F6D61696E005217'
+  end
+
+	it 'should return bytecode to allow all domains if no url is passed' do
+	  SwxAssembler.allow_domain_bytecode.should == '960900005F706172656E74001C960600005F75726C004E960D0007010000000053797374656D001C960A00007365637572697479004E960D0000616C6C6F77446F6D61696E005217'
+	end
+end
+
+require 'zlib'
+
+describe 'SwxAssembler#compress_swx_file' do
+  it 'should remove the first eight bytes of the string before compressing' do
+		@swx_file = '123456789'
+		@swx_file.should_receive(:slice!).with(0...8).and_return('12345678')
+    SwxAssembler.compress_swx_file(@swx_file, 4)
+  end
+
+	it 'should compress the remainder of the string using Zlib' do
+		@swx_file = '123456789'
+		Zlib::Deflate.should_receive(:deflate).with(@swx_file[8..-1], 4).and_return('a compressed string')
+		SwxAssembler.compress_swx_file(@swx_file, 4)
+	end
+end
+
+
+