jbarnette-johnson 1.0.0.200806240111

data/README.rdoc

@@ -0,0 +1,51 @@
+= Johnson
+
+Johnson wraps JavaScript in a loving Ruby embrace.
+
+* {Source Code}[http://github.com/jbarnette/johnson]
+* {Bug Tracker}[http://johnson.lighthouseapp.com]
+* {RubyForge Project}[http://johnson.rubyforge.org]
+
+== Usage
+
+  # FIXME: write some decent examples
+  require "johnson"
+  
+  Johnson.evaluate("4 + 4") # => 8
+  Johnson.evaluate("4 + foo", :foo => 4) # => 8
+  
+== Installing
+
+  [sudo] gem install johnson
+
+== Installing Development Versions
+
+We periodically update Johnson's gemspec on Github. Rather than installing the
+official releases (hosted on RubyForge), you can track the development version.
+Development versions will have a timestamped version number, like 1.0.0.200806232349.
+
+  [sudo] gem sources -a http://gems.github.com   # if you haven't already
+  [sudo] gem install jbarnette-johnson
+
+== License
+
+Copyright 2008 John Barnette, Aaron Patterson, Yehuda Katz, Matthew Draper
+
+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/Rakefile

@@ -0,0 +1,166 @@
+require "erb"
+
+require "./lib/hoe.rb"
+require "./lib/johnson/version.rb"
+
+# what sort of extension are we building?
+kind = Config::CONFIG["DLEXT"]
+
+CROSS = ENV["CROSS"]
+LIBJS = FileList["vendor/spidermonkey/#{CROSS || ''}*.OBJ/libjs.{#{kind},so}"].first || :libjs
+
+GENERATED_NODE = "ext/spidermonkey/immutable_node.c"
+
+HOE = Hoe.new("johnson", Johnson::VERSION) do |p|
+  p.author         = ["John Barnette", "Aaron Patterson", "Yehuda Katz", "Matthew Draper"]
+  p.changes        = p.paragraphs_of("CHANGELOG", 0..1).join("\n\n")
+  p.email          = "johnson-talk@googlegroups.com"
+  p.rubyforge_name = "johnson"
+  p.description    = "Johnson wraps JavaScript in a loving Ruby embrace."
+  p.summary        = p.description
+  p.url            = "http://github.com/jbarnette/johnson/wikis"
+
+  p.clean_globs = [
+    "lib/johnson/spidermonkey.#{kind}",
+    "ext/spidermonkey/Makefile",
+    "ext/spidermonkey/*.{o,so,bundle,log}",
+    GENERATED_NODE,
+    "vendor/spidermonkey/**/*.OBJ"]
+
+  p.test_globs = ["test/**/*_test.rb"]
+  p.spec_extras = { :extensions => ["Rakefile"] }
+  p.extra_deps = ["rake"]
+end
+
+namespace :gem do
+  namespace :spec do
+    task :generate do
+      File.open("johnson.gemspec", "w") do |f|
+        f.puts(HOE.spec.to_ruby)
+      end
+    end
+  end
+end
+
+namespace :test do
+  Rake::TestTask.new("todo") do |t|
+    t.test_files = FileList["todo/**/*_test.rb"]
+    t.verbose = true
+  end
+  
+  task :jspec => :extensions do
+    $LOAD_PATH << File.expand_path(File.dirname(__FILE__) + "/lib")
+    Johnson.send(:remove_const, :VERSION)
+    require "johnson"
+
+    Dir["test/jspec/**/*_spec.js"].each do |file|
+      Johnson::Runtime.new.load(file)
+    end
+  end
+end
+
+# make sure the C bits are up-to-date when testing
+Rake::Task[:test].prerequisites << :extensions
+Rake::Task["test:todo"].prerequisites << :extensions
+
+Rake::Task[:check_manifest].prerequisites << GENERATED_NODE
+
+task :build => :extensions
+task :extension => :build
+
+task :extensions => ["lib/johnson/spidermonkey.#{kind}"]
+
+namespace :extensions do
+  task :clean do
+    Dir.chdir("ext/spidermonkey") do
+      sh "rm -f Makefile"
+      sh "rm -f *.{o,so,bundle,log}"
+    end
+  end
+end
+
+build_sm = lambda do
+  cmd = "make -f Makefile.ref"
+  cmd << " OS_CONFIG=#{CROSS}" if CROSS
+  Dir.chdir("vendor/spidermonkey") { sh cmd }
+end
+
+if Symbol === LIBJS
+  task LIBJS, &build_sm
+else
+  file LIBJS, &build_sm
+
+  task LIBJS => "vendor/spidermonkey/Makefile.ref"
+  task LIBJS => Dir["vendor/spidermonkey/*.[ch]"]
+  task LIBJS => Dir["vendor/spidermonkey/config/*.mk"]
+end
+
+task LIBJS => "vendor/spidermonkey/jsapi.h"
+task LIBJS => "vendor/spidermonkey/config/#{CROSS}.mk" if CROSS
+
+file "vendor/spidermonkey/config/MINGW32.mk" => "MINGW32.mk" do |t|
+  cp t.prerequisites.first, t.name
+end
+
+file "vendor/spidermonkey/jsapi.h" do
+  # if this file's missing, pull in the submodule
+  sh "git submodule init && git submodule update"
+end
+
+file "ext/spidermonkey/spidermonkey.#{kind}" =>
+  ["ext/spidermonkey/Makefile"] + FileList["ext/spidermonkey/*.{c,h}"].to_a do |t|
+
+  old_time = File.mtime(t.name) rescue nil
+  Dir.chdir("ext/spidermonkey") { sh "make" }
+
+  # If make chose not to rebuild the file, we'll touch it, so we don't
+  # bother to call make again next time.
+  sh "touch #{t.name}" if old_time && File.mtime(t.name) <= old_time
+end
+
+# for testing, we toss the SpiderMonkey extension in lib/johnson
+file "lib/johnson/spidermonkey.#{kind}" =>
+  "ext/spidermonkey/spidermonkey.#{kind}" do |t|
+
+  cp t.prerequisites.first, t.name
+end
+
+file "ext/spidermonkey/Makefile" =>
+  [LIBJS, GENERATED_NODE, "ext/spidermonkey/extconf.rb"] do
+  
+  dirs = (CROSS ? [ENV["CROSSLIB"]] : []) + $:
+  command = ["ruby"] + dirs.map{|dir| "-I#{File.expand_path dir}"} + ["extconf.rb"]
+  Dir.chdir("ext/spidermonkey") { sh *command }
+end
+
+def jsops
+  ops = []
+  File.open("vendor/spidermonkey/jsopcode.tbl", "rb") { |f|
+    f.each_line do |line|
+      if line =~ /^OPDEF\((\w+),/
+        ops << $1
+      end
+    end
+  }
+  ops
+end
+
+def tokens
+  toks = []
+  File.open("vendor/spidermonkey/jsscan.h", "rb") { |f|
+    f.each_line do |line|
+      line.scan(/TOK_\w+/).each do |token|
+        next if token == "TOK_ERROR"
+        toks << token
+      end
+    end
+  }
+  toks.uniq
+end
+
+file GENERATED_NODE => ["ext/spidermonkey/immutable_node.c.erb", "vendor/spidermonkey/jsopcode.tbl", "vendor/spidermonkey/jsscan.h"] do |t|
+  template = ERB.new(File.open(t.prerequisites.first, "rb") { |x| x.read })
+  File.open(GENERATED_NODE, "wb") { |f|
+    f.write template.result(binding)
+  }
+end

data/bin/johnson

@@ -0,0 +1,107 @@
+#!/usr/bin/env ruby
+
+begin
+  require "johnson"
+rescue LoadError
+  require "rubygems"
+  require "johnson"
+end
+
+require "readline"
+
+RUNTIME = js = Johnson::Runtime.new
+RUNTIME.evaluate(Johnson::CLI::JS)
+
+EXIT_VERBS = [nil] + %w(exit quit)
+
+local_binding = binding
+ruby_readline = []
+
+def copy_history
+  new_history = []
+  until Readline::HISTORY.empty?
+    new_history.push(Readline::HISTORY.pop)
+  end
+  new_history
+end
+
+def paste_history(old_history)
+  until old_history.empty?
+    Readline::HISTORY << old_history.pop
+  end
+end
+
+def handle_exit(input)
+  if EXIT_VERBS.include?(input)
+    puts if input.nil?
+    exit
+  end
+end
+
+def rescued(&block)
+  yield
+rescue Exception => e
+  exit if SystemExit === e
+
+  puts e.message
+  puts e.backtrace.reject { |l| l =~ /bin\/johnson/ }
+end
+
+def eval_in_js(expression)
+  rescued { puts "=> " + RUNTIME.evaluate(expression, "(console)").inspect }
+end
+
+def eval_in_ruby(expression, bind_to)
+  rescued { puts "=> " + eval(expression, bind_to).inspect }
+end
+
+options = Johnson::CLI::Options.parse!(ARGV)
+options.load_paths.each { |d| $LOAD_PATH << d }
+options.files_to_preload.each { |f| RUNTIME.load(f) }
+
+unless options.expressions.empty?
+  # magic comment, do not remove
+  options.expressions.each { |e| RUNTIME.evaluate(e, '-e') }
+  exit if !options.file_to_evaluate
+end
+
+if options.file_to_evaluate
+  RUNTIME[:arguments] = options.arguments
+  RUNTIME.load(options.file_to_evaluate)
+  exit
+end
+
+loop do
+  input = Readline.readline("js> ", true)
+  handle_exit(input)
+  
+  if input =~ /^rb\s+(.+)$/
+    eval_in_ruby($1, local_binding)
+    next
+  end
+  
+  if input == "rb"
+    js_readline = copy_history
+    paste_history(ruby_readline)
+    
+    loop do
+      input = Readline.readline("rb> ", true)
+      handle_exit(input)
+
+      break if input == "js"
+
+      if input =~ /^js\s+(.+)$/
+        eval_in_js($1)
+        next
+      end
+
+      eval_in_ruby(input, local_binding)
+    end
+    
+    ruby_readline = copy_history
+    paste_history(js_readline)
+    next
+  end
+  
+  eval_in_js(input)
+end

data/cross-compile.txt

@@ -0,0 +1,38 @@
+
+CROSS-COMPILING FOR WINDOWS
+
+Based on http://eigenclass.org/hiki.rb?cross+compiling+rcovrt
+
+
+*) Install the MinGW cross-compiler
+
+    Debian: apt-get install mingw32 mingw32-binutils mingw32-runtime
+
+*) Download & extract a ruby distribution archive
+
+*) Double the backslashes in the ALT_SEPARATOR definition in Makefile.in
+
+*) Build & install it:
+
+    env ac_cv_func_getpgrp_void=no \
+       ac_cv_func_setpgrp_void=yes \
+       rb_cv_negative_time_t=no \
+       ac_cv_func_memcmp_working=yes \
+       rb_cv_binary_elf=no \
+       ./configure \
+       --host=i586-mingw32msvc \
+       --target=i386-mingw32 \
+       --build=i686-linux \
+       --prefix=~/ruby-mingw32
+
+    make ruby
+
+    make install
+
+*) Build the extension (rake will build spidermonkey for you)
+
+    # Remove any native binaries that are already built
+    rake clean
+
+    rake build CROSS=MINGW32 CROSSLIB=~/ruby-mingw32/lib/ruby/1.8/i386-mingw32
+

data/ext/spidermonkey/context.c

@@ -0,0 +1,122 @@
+#include "context.h"
+#include "conversions.h"
+#include "global.h"
+#include "extensions.h"
+#include "idhash.h"
+#include "jsdbgapi.h"
+
+// callback for JS_SetErrorReporter
+static void report_js_error(JSContext* js, const char* message, JSErrorReport* UNUSED(report))
+{
+  // first we find ourselves
+  VALUE self = (VALUE)JS_GetContextPrivate(js);
+
+  // then we find our bridge
+  JohnsonContext* context;
+  Data_Get_Struct(self, JohnsonContext, context);
+
+  // NOTE: SpiderMonkey REALLY doesn't like being interrupted. If we
+  // jump over to Ruby and raise here, segfaults and such ensue.
+  // Instead, we store the exception (if any) and the error message
+  // on the context. They're dealt with in the if (!ok) block of evaluate().
+
+  strncpy(context->msg, message, MAX_EXCEPTION_MESSAGE_SIZE);
+  JS_GetPendingException(context->js, &context->ex);
+}
+
+// callback for JS_SetBranchCallback
+static JSBool branch_callback(JSContext* js, JSScript* UNUSED(script))
+{
+  static unsigned long branch_counter = 0;
+  if( ++branch_counter % 0x1000 == 0 )
+    JS_MaybeGC( js );
+  return JS_TRUE;
+}
+
+/*
+ * call-seq:
+ *   native_initialize(options={})
+ *
+ * Initializes the native spidermonkey values.
+ */
+static VALUE
+initialize_native(VALUE self, VALUE rb_runtime, VALUE UNUSED(options))
+{
+  JohnsonContext* context;
+  JohnsonRuntime* runtime;
+
+  Data_Get_Struct(self, JohnsonContext, context);
+  Data_Get_Struct(rb_runtime, JohnsonRuntime, runtime);
+
+  if ((context->js = JS_NewContext(runtime->js, 8192)))
+  {
+    // See if the runtime already has a shared global object.
+    JSObject* global = runtime->global;
+
+    // If it does, use it. If not,
+    if (!global)
+      // create one of our global objects.
+      global = johnson_create_global_object(context->js);
+
+    // Manually set the context's global object.
+    JS_SetGlobalObject(context->js, global);
+    JS_SetErrorReporter(context->js, report_js_error);
+    JS_SetBranchCallback(context->js, branch_callback);
+    JS_SetContextPrivate(context->js, (void *)self);
+
+    JS_SetOptions(context->js, JS_GetOptions(context->js)
+#ifdef JSOPTION_DONT_REPORT_UNCAUGHT
+        | JSOPTION_DONT_REPORT_UNCAUGHT
+#endif
+#ifdef JSOPTION_VAROBJFIX
+        | JSOPTION_VAROBJFIX
+#endif
+// #ifdef JSOPTION_XML
+//         | JSOPTION_XML
+// #endif
+        );
+
+    // Success.
+    return init_spidermonkey_extensions(context, self);
+  }
+
+  if (context->js) JS_DestroyContext(context->js);
+
+  rb_raise(rb_eRuntimeError, "Failed to initialize SpiderMonkey context");
+}
+
+///////////////////////////////////////////////////////////////////////////
+//// INFRASTRUCTURE BELOW HERE ////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
+
+static void deallocate(JohnsonContext* context)
+{
+  JS_SetContextPrivate(context->js, 0);
+  JS_DestroyContext(context->js);
+  free(context);
+}
+
+static VALUE allocate(VALUE klass)
+{
+  JohnsonContext* context = calloc(1, sizeof(JohnsonContext));
+  return Data_Wrap_Struct(klass, 0, deallocate, context);
+}
+
+void init_Johnson_SpiderMonkey_Context(VALUE spidermonkey)
+{
+  /* HACK:  These comments are *only* to make RDoc happy.
+  VALUE johnson = rb_define_module("Johnson");
+  VALUE spidermonkey = rb_define_module_under(johnson, "SpiderMonkey");
+  */
+
+  /* This is the private context used for SpiderMonkey. */
+  VALUE context = rb_define_class_under(spidermonkey, "Context", rb_cObject);
+
+  rb_define_alloc_func(context, allocate);
+  rb_define_private_method(context, "initialize_native", initialize_native, 2);
+}
+
+VALUE Johnson_SpiderMonkey_JSLandProxy()
+{
+  return rb_eval_string("Johnson::SpiderMonkey::JSLandProxy");
+}