execjs-async 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+*.gem
+.bundle
+pkg/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm gemset use execjs-async

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in execjs-async.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,18 @@
+PATH
+  remote: .
+  specs:
+    execjs-async (0.0.1)
+      execjs (~> 1.1.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    execjs (1.1.3)
+      multi_json (~> 1.0)
+    multi_json (1.0.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  execjs-async!

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+task :default => :test
+
+desc "Run tests"
+Rake::TestTask.new("test") { |t|
+  t.libs << "test"
+  t.verbose = true
+  t.warning = true
+}

data/execjs-async.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "execjs-async/version"
+
+Gem::Specification.new do |s|
+  s.name        = "execjs-async"
+  s.version     = Execjs::Async::VERSION
+  s.authors     = ["Eric Allam"]
+  s.email       = ["rubymaverick@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Enables Asynchronous Javascript Execution in ExecJS}
+  s.description = %q{Enables Asynchronous Javascript Execution in ExecJS}
+
+  s.rubyforge_project = "execjs-async"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  s.add_runtime_dependency "execjs", '~> 1.1.0'
+end

data/lib/execjs-async.rb

@@ -0,0 +1,62 @@
+require "execjs-async/version"
+require 'execjs'
+
+module Execjs
+  module Async
+    
+    # extend from nodes external runtime context, and
+    # overwrite compile to use the async source.    
+    class Context < ExecJS::ExternalRuntime::Context
+      ASYNC_SOURCE = <<-'JAVASCRIPT'
+        (function(program, execJS, module, exports, require) { execJS(program) })(function(callback) { #{source}
+        }, function(program) {
+          var output, print = function(string) {
+            process.stdout.write('' + string);
+          };
+          try {
+            program(function(result){
+              if (typeof result == 'undefined' && result !== null) {
+                print('["ok"]');
+              } else {
+                try {
+                  print(JSON.stringify(['ok', result]));
+                } catch (err) {
+                  print('["err"]');
+                }
+              } 
+            });
+          } catch (err) {
+            print(JSON.stringify(['err', '' + err]));
+          }
+        });
+      JAVASCRIPT
+      
+      def compile(source)        
+        ASYNC_SOURCE.dup.tap do |output|
+          output.sub!('#{source}') do
+            source
+          end
+          output.sub!('#{encoded_source}') do
+            encoded_source = encode_unicode_codepoints(source)
+            MultiJson.encode("(function(){ #{encoded_source} })()")
+          end
+          output.sub!('#{json2_source}') do
+            IO.read(ExecJS.root + "/support/json2.js")
+          end
+        end
+      end
+    end
+    
+    def compile_async(source)
+      Context.new(self, source)
+    end
+  end
+  
+  ExecJS::Runtimes::Node.singleton_class.send(:include, Async)
+  
+  ExecJS.module_eval do
+    def self.compile_async(source)
+      runtime.compile_async(source)
+    end
+  end
+end

data/lib/execjs-async/version.rb

@@ -0,0 +1,5 @@
+module Execjs
+  module Async
+    VERSION = "0.0.1"
+  end
+end

data/test/support.rb

@@ -0,0 +1,11 @@
+require "test/unit"
+require "execjs/module"
+
+begin
+  require "execjs-async"
+rescue ExecJS::RuntimeUnavailable => e
+  warn e
+  exit 2
+end
+
+

data/test/test_execjs.rb

@@ -0,0 +1,58 @@
+require "support"
+
+class TestExecJS < Test::Unit::TestCase
+  def test_exec
+    assert_equal true, ExecJS.exec("return true")
+  end
+
+  def test_eval
+    assert_equal ["red", "yellow", "blue"], ExecJS.eval("'red yellow blue'.split(' ')")
+  end
+
+  def test_runtime_available
+    runtime = ExecJS::ExternalRuntime.new(:command => "nonexistent")
+    assert !runtime.available?
+
+    runtime = ExecJS::ExternalRuntime.new(:command => "ruby")
+    assert runtime.available?
+  end
+
+  def test_runtime_assignment
+    original_runtime = ExecJS.runtime
+    runtime = ExecJS::ExternalRuntime.new(:command => "nonexistent")
+    assert_raises(ExecJS::RuntimeUnavailable) { ExecJS.runtime = runtime }
+    assert_equal original_runtime, ExecJS.runtime
+
+    runtime = ExecJS::ExternalRuntime.new(:command => "ruby")
+    ExecJS.runtime = runtime
+    assert_equal runtime, ExecJS.runtime
+  end
+
+  def test_compile
+    context = ExecJS.compile("foo = function() { return \"bar\"; }")
+    assert_equal "bar", context.exec("return foo()")
+    assert_equal "bar", context.eval("foo()")
+  end
+  
+  def test_compile_async
+    context = ExecJS.compile_async("foo = function() { callback('bar') }")
+    assert_equal "bar", context.eval("foo()")
+  end
+
+  def test_context_call
+    context = ExecJS.compile("id = function(v) { return v; }")
+    assert_equal "bar", context.call("id", "bar")
+  end
+
+  def test_nested_context_call
+    context = ExecJS.compile("a = {}; a.b = {}; a.b.id = function(v) { return v; }")
+    assert_equal "bar", context.call("a.b.id", "bar")
+  end
+
+  def test_context_call_missing_function
+    context = ExecJS.compile("")
+    assert_raises ExecJS::ProgramError do
+      context.call("missing")
+    end
+  end
+end

data/test/test_runtime.rb

@@ -0,0 +1,117 @@
+# -*- coding: utf-8 -*-
+require "support"
+
+class TestRuntime < Test::Unit::TestCase
+  def setup
+    # only use node for now
+    @runtime = ExecJS::Runtimes::Node
+  end
+
+  def test_exec
+    assert_nil @runtime.exec("1")
+    assert_nil @runtime.exec("return")
+    assert_nil @runtime.exec("return null")
+    assert_nil @runtime.exec("return function() {}")
+    assert_equal 0, @runtime.exec("return 0")
+    assert_equal true, @runtime.exec("return true")
+    assert_equal [1, 2], @runtime.exec("return [1, 2]")
+    assert_equal "hello", @runtime.exec("return 'hello'")
+    assert_equal({"a"=>1,"b"=>2}, @runtime.exec("return {a:1,b:2}"))
+    assert_equal "café", @runtime.exec("return 'café'")
+    assert_equal "☃", @runtime.exec('return "☃"')
+    assert_equal "☃", @runtime.exec('return "\u2603"')
+    assert_equal "\\", @runtime.exec('return "\\\\"')
+  end
+  
+  def test_eval
+    assert_nil @runtime.eval("")
+    assert_nil @runtime.eval(" ")
+    assert_nil @runtime.eval("null")
+    assert_nil @runtime.eval("function() {}")
+    assert_equal 0, @runtime.eval("0")
+    assert_equal true, @runtime.eval("true")
+    assert_equal [1, 2], @runtime.eval("[1, 2]")
+    assert_equal [1, nil], @runtime.eval("[1, function() {}]")
+    assert_equal "hello", @runtime.eval("'hello'")
+    assert_equal({"a"=>1,"b"=>2}, @runtime.eval("{a:1,b:2}"))
+    assert_equal({"a"=>true}, @runtime.eval("{a:true,b:function (){}}"))
+    assert_equal "café", @runtime.eval("'café'")
+    assert_equal "☃", @runtime.eval('"☃"')
+    assert_equal "☃", @runtime.eval('"\u2603"')
+    assert_equal "\\", @runtime.eval('"\\\\"')
+  end
+  
+  if defined? Encoding
+    def test_encoding
+      utf8 = Encoding.find('UTF-8')
+  
+      assert_equal utf8, @runtime.exec("return 'hello'").encoding
+      assert_equal utf8, @runtime.eval("'☃'").encoding
+  
+      ascii = "'hello'".encode('US-ASCII')
+      result = @runtime.eval(ascii)
+      assert_equal "hello", result
+      assert_equal utf8, result.encoding
+  
+      assert_raise Encoding::UndefinedConversionError do
+        binary = "\xde\xad\xbe\xef".force_encoding("BINARY")
+        @runtime.eval(binary)
+      end
+    end
+  
+    def test_encoding_compile
+      utf8 = Encoding.find('UTF-8')
+  
+      context = @runtime.compile("foo = function(v) { return '¶' + v; }".encode("ISO8859-15"))
+  
+      assert_equal utf8, context.exec("return foo('hello')").encoding
+      assert_equal utf8, context.eval("foo('☃')").encoding
+  
+      ascii = "foo('hello')".encode('US-ASCII')
+      result = context.eval(ascii)
+      assert_equal "¶hello", result
+      assert_equal utf8, result.encoding
+  
+      assert_raise Encoding::UndefinedConversionError do
+        binary = "\xde\xad\xbe\xef".force_encoding("BINARY")
+        context.eval(binary)
+      end
+    end
+  end
+  
+  def test_compile
+    context = @runtime.compile("foo = function() { return \"bar\"; }")
+    assert_equal "bar", context.exec("return foo()")
+    assert_equal "bar", context.eval("foo()")
+    assert_equal "bar", context.call("foo")
+  end
+  
+  def test_compile_with_async
+    context = @runtime.compile_async("foo = function() { callback('bar') }")
+    assert_equal "bar", context.call("foo")
+    assert_equal "bar", context.eval("foo()")
+    assert_equal "bar", context.exec("return foo()")
+  end
+
+  def test_this_is_global_scope
+    assert_equal true, @runtime.eval("this === (function() {return this})()")
+    assert_equal true, @runtime.exec("return this === (function() {return this})()")
+  end
+  
+  def test_compile_large_scripts
+    body = "var foo = 'bar';\n" * 100_000
+    assert @runtime.exec("function foo() {\n#{body}\n};\nreturn true")
+  end
+  
+  def test_syntax_error
+    assert_raise ExecJS::RuntimeError do
+      @runtime.exec(")")
+    end
+  end
+  
+  def test_thrown_exception
+    assert_raise ExecJS::ProgramError do
+      @runtime.exec("throw 'hello'")
+    end
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: execjs-async
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Eric Allam
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-28 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: execjs
+  requirement: &70268197049220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70268197049220
+description: Enables Asynchronous Javascript Execution in ExecJS
+email:
+- rubymaverick@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- execjs-async.gemspec
+- lib/execjs-async.rb
+- lib/execjs-async/version.rb
+- test/support.rb
+- test/test_execjs.rb
+- test/test_runtime.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: execjs-async
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Enables Asynchronous Javascript Execution in ExecJS
+test_files:
+- test/support.rb
+- test/test_execjs.rb
+- test/test_runtime.rb