therubyracer-freebsd 0.10.1

data/lib/v8/array.rb

@@ -0,0 +1,17 @@
+
+module V8
+  class Array < V8::Object
+    
+    def each
+      @portal.open do |to|
+        for i in 0..(@native.Length() - 1)
+          yield to.rb(@native.Get(i))
+        end
+      end
+    end
+
+    def length
+      @native.Length()
+    end
+  end
+end

data/lib/v8/c/locker.rb

@@ -0,0 +1,18 @@
+module V8
+  module C
+    # Shim to support the old style locking syntax. We don't currently
+    # deprecate this because it might make a comeback at some point.
+    #
+    # to synchronize access to V8, and to associate V8 with this thread:
+    #
+    #     Locker() do
+    #       #... interact with v8
+    #     end
+    def self.Locker
+      lock = Locker.new
+      yield
+    ensure
+      lock.delete
+    end
+  end
+end

data/lib/v8/cli.rb

@@ -0,0 +1,133 @@
+require 'optparse'
+require 'ostruct'
+
+module V8
+  module CLI
+    def self.run(exename = 'v8', args = [])
+      options = OpenStruct.new
+      options.libs = []
+      options.libdirs = []
+      parser = OptionParser.new
+      parser.banner = "Usage: #{exename} [options]"
+      parser.on("-r", "--require FILE", "load and execute FILE as JavaScript source") {|r| options.libs << r}
+      parser.on("-i", "--interactive", "interactive mode") {options.interactive = true}
+      parser.on("-e", "--execute JAVASCRIPT", String, "evaluate JAVASCRIPT and exit") {|src| options.execute = src}
+      parser.on("--selftest", "check that therubyracer is functioning properly") {options.selftest = true}
+      parser.on_tail("-v", "--version", "Show version and exit") {options.version_info = true}
+      parser.on_tail("-h", "--help", "Show this message") do
+        puts parser
+        exit
+      end
+      begin
+        parser.parse!(args.dup)
+      rescue OptionParser::InvalidOption => e
+        puts "#{exename}: #{e.message}"
+        exit(1)
+      end
+      if options.version_info
+        require 'libv8'
+        puts "The Ruby Racer #{V8::VERSION}"
+        puts "V8 Version #{Libv8::V8_VERSION}"
+        exit
+      elsif options.selftest
+        self.test
+      end
+      Context.new(:with => Shell.new) do |cxt|
+        for libfile in options.libs do
+          load(cxt,libfile)
+        end
+        if options.interactive
+          repl(cxt, exename)
+        elsif options.execute
+          cxt.eval(options.execute, '<execute>')
+        else
+          begin
+            cxt.eval($stdin, '<stdin>')
+          rescue Interrupt => e
+            puts; exit
+          end
+        end
+      end
+    end
+
+    def self.load(cxt, libfile)
+      begin
+        cxt.load(libfile)
+      rescue V8::JSError => e
+        puts e.message
+        puts e.backtrace(:javascript)
+      rescue StandardError => e
+        puts e
+      end
+    end
+
+    def self.test
+      begin
+        require 'rspec'
+        specs = File.expand_path('../../../spec', __FILE__)
+        $:.unshift specs
+        ARGV.clear
+        ARGV << specs
+        ::RSpec::Core::Runner.autorun
+        exit(0)
+      rescue LoadError => e
+        puts "selftest requires rspec to be installed (gem install rspec)"
+        exit(1)
+      end
+
+    end
+
+    def self.repl(cxt, exename)
+      require 'readline'
+      puts "help() for help. quit() to quit."
+      puts "The Ruby Racer #{V8::VERSION}"
+      puts "Vroom Vroom!"
+      trap("SIGINT") do
+        puts "^C"
+      end
+      loop do
+        line = Readline.readline("#{exename}> ", true)
+        begin
+          result = cxt.eval(line, '<shell>')
+          puts(result) unless result.nil?
+        rescue V8::JSError => e
+          puts e.message
+          puts e.backtrace(:javascript)
+        rescue StandardError => e
+          puts e
+          puts e.backtrace.join("\n")
+        end
+      end
+    end
+
+    class Shell
+      def to_s
+        "[object Shell]"
+      end
+
+      def print(string)
+        puts string
+      end
+
+      def exit(status = 0)
+        Kernel.exit(status)
+      end
+
+      alias_method :quit, :exit
+
+      def help(*args)
+        <<-HELP
+    print(msg)
+      print msg to STDOUT
+
+    exit(status = 0)
+      exit the shell
+      also: quit()
+
+    evalrb(source)
+      evaluate some ruby source
+    HELP
+      end
+    end
+  end
+end

data/lib/v8/context.rb

@@ -0,0 +1,111 @@
+require 'stringio'
+
+module V8
+  class Context
+    attr_reader :native, :scope, :access
+
+    def initialize(opts = {})
+      @access = Access.new
+      @to = Portal.new(self, @access)
+      @to.lock do
+        with = opts[:with]
+        constructor = nil
+        template = if with
+          constructor = @to.templates.to_constructor(with.class)
+          constructor.disable()
+          constructor.template.InstanceTemplate()
+        else
+          C::ObjectTemplate::New()
+        end
+        @native = opts[:with] ? C::Context::New(template) : C::Context::New()
+        @native.enter do
+          @global = @native.Global()
+          @to.proxies.register_javascript_proxy @global, :for => with if with
+          constructor.enable() if constructor
+          @scope = @to.rb(@global)
+          @global.SetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyContext"), C::External::New(self))
+        end
+        yield(self) if block_given?
+      end
+    end
+
+    def eval(javascript, filename = "<eval>", line = 1)
+      if IO === javascript || StringIO === javascript
+        javascript = javascript.read()
+      end
+      err = nil
+      value = nil
+      @to.lock do
+        C::TryCatch.try do |try|
+          @native.enter do
+            script = C::Script::Compile(@to.v8(javascript.to_s), @to.v8(filename.to_s))
+            if try.HasCaught()
+              err = JSError.new(try, @to)
+            else
+              result = script.Run()
+              if try.HasCaught()
+                err = JSError.new(try, @to)
+              else
+                value = @to.rb(result)
+              end
+            end
+          end
+        end
+      end
+      raise err if err
+      return value
+    end
+
+    def load(filename)
+      File.open(filename) do |file|
+        self.eval file, filename, 1
+      end
+    end
+
+    def [](key)
+      @to.open do
+        @to.rb @global.Get(@to.v8(key))
+      end
+    end
+
+    def []=(key, value)
+      @to.open do
+        @global.Set(@to.v8(key), @to.v8(value))
+      end
+      return value
+    end
+
+    def self.stack(limit = 99)
+      if native = C::Context::GetEntered()
+        global = native.Global()
+        cxt = global.GetHiddenValue(C::String::NewSymbol("TheRubyRacer::RubyContext")).Value()
+        cxt.instance_eval {@to.rb(C::StackTrace::CurrentStackTrace(limit))}
+      else
+        []
+      end
+    end
+    
+    def self.passes_this_argument?
+      true
+    end
+  end
+
+  module C
+    class Context
+      def enter
+        if block_given?
+          if IsEntered()
+            yield(self)
+          else
+            Enter()
+            begin
+              yield(self)
+            ensure
+              Exit()
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/v8/error.rb

@@ -0,0 +1,130 @@
+
+module V8
+  class JSError < StandardError
+    attr_reader :value, :boundaries
+
+    def initialize(try, to)
+      @to = to
+      super(initialize_unsafe(try))
+    rescue Exception => e
+      @boundaries = [Boundary.new(:rbframes => e.backtrace)]
+      @value = e
+      super(<<-EOMSG)
+You have uncovered what is probably a BUG in therubyracer exception code. An error report would be very helpful.
+JSError#initialize failed!: #{e.message}"
+EOMSG
+    end
+
+    def initialize_unsafe(try)
+      message = nil
+      ex = @to.rb(try.Exception())
+      @boundaries = [Boundary.new(:rbframes => caller(3), :jsframes => parse_js_frames(try))]
+      if V8::Object === ex
+        if msg = ex['message']
+          message = msg
+        else
+          message = ex.to_s
+        end
+        if cause = ex.instance_variable_get(:@native).GetHiddenValue("TheRubyRacer::Cause")
+          if !cause.IsEmpty()
+            prev = cause.Value()
+            if prev.kind_of?(JSError)
+              @boundaries.concat prev.boundaries
+              @value = prev.value
+            else
+              @value = prev
+              @boundaries.concat [Boundary.new(:rbframes => prev.backtrace)]
+            end
+          else
+            @value = ex
+          end
+        end
+      else
+        @value = ex
+        message = ex.to_s
+      end
+      return message
+    end
+
+    def in_ruby?
+      @value.kind_of?(Exception)
+    end
+
+    def in_javascript?
+      !in_ruby?
+    end
+
+    def backtrace(*modifiers)
+      trace_framework = modifiers.include?(:framework)
+      trace_ruby = modifiers.length == 0 || modifiers.include?(:ruby)
+      trace_javascript = modifiers.length == 0 || modifiers.include?(:javascript)
+      mixed = []
+      rbcontext = []
+      jscontext = []
+      @boundaries.each do |b|
+        rbframes = b.rbframes.dup
+        rbcontext.reverse_each do |frame|
+          if frame == rbframes.last
+            rbframes.pop
+          else
+            break
+          end
+        end if trace_ruby
+        jsframes = b.jsframes.dup
+        jscontext.reverse_each do |frame|
+          if frame == jsframes.last
+            jsframes.pop
+          else
+            break
+          end
+        end if trace_javascript
+        rbcontext = b.rbframes
+        jscontext = b.jsframes
+        rbframes.reject! {|f| f =~ /lib\/v8\/.*\.rb/} unless trace_framework
+        mixed.unshift(*rbframes) if trace_ruby
+        mixed.unshift(*jsframes) if trace_javascript
+      end
+      return mixed
+    end
+
+    def parse_js_frames(try)
+      #I can't figure out why V8 is not capturing the stacktrace here
+      #in terms of StackTrace and StackFrame objects, so we have to
+      #parse the string.
+      raw = @to.rb(try.StackTrace())
+      if raw && !raw.empty? && !syntax_error?(try)
+        raw.split("\n")[1..-1].tap do |frames|
+          frames.each {|frame| frame.strip!; frame.chomp!(",")}
+        end.reject(&:empty?)
+      else
+        msg = try.Message()
+        ["at #{@to.rb(msg.GetScriptResourceName())}:#{msg.GetLineNumber()}:#{msg.GetStartColumn() + 1}"]
+      end
+    end
+
+    #Syntax errors are weird in that they have a non-empty stack trace
+    #but it does not contain any source location information, so
+    #in these instances, we have to pull it out of the Message object
+    #in the TryCatch. Is there a better way to detect a syntax error
+    def syntax_error?(try)
+      ex = @to.rb(try.Exception())
+      if ex && ex.kind_of?(V8::Object)
+        type = ex["constructor"]
+        type && type.kind_of?(V8::Function) && type.name == "SyntaxError"
+      else
+        false
+      end
+    end
+
+    class Boundary
+      attr_reader :rbframes, :jsframes
+
+      def initialize(frames = {})
+        @rbframes = frames[:rbframes] || []
+        @jsframes = frames[:jsframes] || []
+      end
+    end
+  end
+  #deprecated -- use JSError
+  JavasriptError = JSError
+end

data/lib/v8/function.rb

@@ -0,0 +1,44 @@
+module V8
+  class Function < V8::Object
+
+    def methodcall(thisObject, *args)
+      err = nil
+      return_value = nil
+      @portal.open do |to|
+        C::TryCatch.try do |try|
+          this = to.v8(thisObject)
+          return_value = to.rb(@native.Call(this, to.v8(args)))
+          err = JSError.new(try, to) if try.HasCaught()
+        end
+      end
+      raise err if err
+      return return_value
+    end
+
+    def call(*args)
+      @portal.open do
+        self.methodcall(@portal.context.native.Global(), *args)
+      end
+    end
+
+    def new(*args)
+      @portal.open do |to|
+        to.rb(@native.NewInstance(to.v8(args)))
+      end
+    end
+
+    def name
+      @portal.open do |to|
+        to.rb(@native.GetName())
+      end
+    end
+
+    def name=(name)
+      name.tap do
+        @portal.open do |to|
+          @native.SetName(to.v8(name))
+        end
+      end
+    end
+  end
+end