classiccms 0.3.0 → 0.3.1

data/vendor/bundle/gems/therubyracer-0.10.1/ext/v8/v8_weakref.cpp

@@ -0,0 +1,61 @@
+#include "v8.h"
+#include "v8_weakref.h"
+
+using namespace v8;
+
+v8_weakref::v8_weakref(VALUE object) {
+  this->v8_active = true;
+  this->rb_active = true;
+  this->external = Persistent<External>::New(External::New((void *)this));
+  this->external.MakeWeak(this, v8_weakref_dispose);
+  this->set(object);
+}
+
+void v8_weakref::set(VALUE value) {
+  this->object_id = rb_obj_id(value);
+  this->rb_active = true;
+  VALUE data = Data_Wrap_Struct(rb_cObject, 0, 0, this);
+  rr_define_finalizer(value,(void*)v8_weakref_finalize, data);
+}
+
+VALUE v8_weakref::get() {
+  if (this->object_id) {
+    return rb_rescue((VALUE (*)(...))v8_weakref_id2ref, this->object_id, (VALUE (*)(...))v8_weakref_nil, Qnil);
+  } else {
+    return Qnil;
+  }
+}
+
+VALUE v8_weakref_finalize(VALUE object_id, VALUE data) {
+  v8_weakref* weakref = 0;
+  Data_Get_Struct(data, struct v8_weakref, weakref);
+  weakref->object_id = Qnil;
+  weakref->rb_active = false;
+  if (!weakref->v8_active) {
+    delete weakref;
+  }
+  return Qnil;
+}
+
+void v8_weakref_dispose(Persistent<Value> value, void* data) {
+  value.Dispose();
+  value.Clear();
+  v8_weakref* weakref = (v8_weakref*)data;
+  weakref->v8_active = false;
+  if (!weakref->rb_active) {
+    delete weakref;
+  }
+}
+
+VALUE v8_weakref_nil(VALUE nil, VALUE exception) {
+  return nil;
+}
+
+VALUE v8_weakref_objectspace() {
+  return rb_const_get(rb_cObject, rb_intern("ObjectSpace"));
+}
+
+VALUE v8_weakref_id2ref(VALUE id) {
+  return rb_funcall(v8_weakref_objectspace(), rb_intern("_id2ref"), 1, id);
+}
+

data/vendor/bundle/gems/therubyracer-0.10.1/ext/v8/v8_weakref.h

@@ -0,0 +1,29 @@
+#ifndef _RR_V8_WEAKREF_
+#define _RR_V8_WEAKREF_ 
+
+#include <v8.h>
+#include "ruby.h"
+#include "rr.h"
+
+struct v8_weakref  {
+  v8_weakref(VALUE object);
+  VALUE get();
+  void set(VALUE object);
+  void retain();
+  void release();
+
+  VALUE object_id;
+  bool v8_active;
+  bool rb_active;
+  v8::Persistent<v8::External> external;
+};
+
+void  v8_weakref_dispose(v8::Persistent<v8::Value> value, void* weakref);
+VALUE v8_weakref_finalize(VALUE self, VALUE object_id);
+VALUE v8_weakref_objectspace();
+VALUE v8_weakref_nil(VALUE nil, VALUE exception);
+VALUE v8_weakref_id2ref(VALUE id);
+
+// extern "C" VALUE rb_proc_new(VALUE (*)(ANYARGS/* VALUE yieldarg[, VALUE procarg] */), VALUE);
+
+#endif

data/vendor/bundle/gems/therubyracer-0.10.1/lib/v8/access.rb

@@ -0,0 +1,87 @@
+require 'set'
+module V8
+  class Access
+    def get(obj, name, &dontintercept)
+      methods = accessible_methods(obj)
+      if methods.include?(name)
+        method = obj.method(name)
+        method.arity == 0 ? method.call : method.unbind
+      elsif obj.respond_to?(:[])
+        obj.send(:[], name, &dontintercept)
+      else
+        yield
+      end
+    end
+
+    def iget(obj, index, &dontintercept)
+      if obj.respond_to?(:[])
+        obj.send(:[], index, &dontintercept)
+      else
+        yield
+      end
+    end
+
+    def set(obj, name, value, &dontintercept)
+      setter = name + "="
+      methods = accessible_methods(obj, true)
+      if methods.include?(setter)
+        obj.send(setter, value)
+      elsif obj.respond_to?(:[]=)
+        obj.send(:[]=, name, value, &dontintercept)
+      else
+        yield
+      end
+    end
+
+    def iset(obj, index, value, &dontintercept)
+      if obj.respond_to?(:[]=)
+        obj.send(:[]=, index, value, &dontintercept)
+      else
+        yield
+      end
+    end
+
+    def query(obj, name, attributes)
+      if obj.respond_to?(name)
+        attributes.dont_delete
+        unless obj.respond_to?(name + "=")
+          attributes.read_only
+        end
+      else
+        yield
+      end
+    end
+
+    def iquery(obj, index, attributes)
+      if obj.respond_to?(:[])
+        attributes.dont_delete
+        unless obj.respond_to?(:[]=)
+          attributes.read_only
+        end
+      else
+        yield
+      end
+    end
+
+    def names(obj)
+      accessible_methods(obj)
+    end
+
+    def indices(obj)
+      obj.respond_to?(:length) ? (0..obj.length).to_a : yield
+    end
+
+    private
+
+    def accessible_methods(obj, special_methods = false)
+      obj.public_methods(false).map {|m| m.to_s}.to_set.tap do |methods|
+        ancestors = obj.class.ancestors.dup
+        while ancestor = ancestors.shift
+          break if ancestor == ::Object
+          methods.merge(ancestor.public_instance_methods(false).map {|m| m.to_s})
+        end
+        methods.reject! {|m| m == "[]" || m == "[]=" || m =~ /=$/} unless special_methods
+      end
+    end
+  end
+end 

data/vendor/bundle/gems/therubyracer-0.10.1/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/vendor/bundle/gems/therubyracer-0.10.1/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/vendor/bundle/gems/therubyracer-0.10.1/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/vendor/bundle/gems/therubyracer-0.10.1/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/vendor/bundle/gems/therubyracer-0.10.1/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/vendor/bundle/gems/therubyracer-0.10.1/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

data/vendor/bundle/gems/therubyracer-0.10.1/lib/v8/object.rb

@@ -0,0 +1,69 @@
+
+module V8
+  class Object
+    include Enumerable
+
+    def initialize(native, portal)
+      @native, @portal = native, portal
+    end
+
+    def [](key)
+      @portal.open do |to|
+        to.rb(@native.Get(to.v8(key)))
+      end
+    end
+
+    def []=(key, value)
+      value.tap do
+        @portal.open do |to|
+          @native.Set(to.v8(key), to.v8(value))
+        end
+      end
+    end
+
+    def to_s
+      @portal.open do |to|
+        to.rb(@native.ToString())
+      end
+    end
+
+    def each
+      @portal.open do |to|
+        for prop in to.rb(@native.GetPropertyNames())
+          yield prop, self[prop]
+        end
+      end
+    end
+
+    def respond_to?(method)
+      super or self[method] != nil
+    end
+
+    def method_missing(name, *args, &block)
+      if name.to_s =~ /(.*)=$/
+        if args.length > 1
+          self[$1] = args
+          return args
+        else
+          self[$1] = args.first
+          return args
+        end
+      end
+      return super(name, *args, &block) unless self.respond_to?(name)
+      property = self[name]
+      if property.kind_of?(V8::Function)
+        property.methodcall(self, *args)
+      elsif args.empty?
+        property
+      else
+        raise ArgumentError, "wrong number of arguments (#{args.length} for 0)" unless args.empty?
+      end
+    end
+  end
+end
+
+class Object  
+  def eval_js(javascript)
+    V8::Context.new(:with => self).eval(javascript)
+  end
+end