h8 0.0.1 → 0.0.2

data/ext/h8/main.cpp

@@ -0,0 +1,162 @@
+#include <h8.h>
+#include <include/libplatform/libplatform.h>
+
+using namespace h8;
+
+extern "C" {
+void Init_h8(void);
+}
+
+VALUE h8_exception;
+VALUE context_class;
+VALUE value_class;
+
+ID id_is_a;
+
+static void rvalue_free(void* ptr) {
+	delete (JsGate*) ptr;
+}
+
+void h8::rvalue_mark(void* ptr) {
+	JsGate *gate = (JsGate*)ptr;
+	rb_gc_mark(gate->h8->self);
+}
+
+VALUE rvalue_alloc(VALUE klass) {
+	return Data_Wrap_Struct(klass, h8::rvalue_mark, rvalue_free, new JsGate);
+}
+
+inline JsGate* rv(VALUE self) {
+	JsGate *gate;
+	Data_Get_Struct(self, JsGate, gate);
+	return gate;
+}
+
+static VALUE rvalue_to_s(VALUE self) {
+	return rv(self)->to_s();
+}
+
+static VALUE rvalue_to_i(VALUE self) {
+	return rv(self)->to_i();
+}
+
+static VALUE rvalue_is_int(VALUE self) {
+	return rv(self)->is_int();
+}
+
+static VALUE rvalue_is_float(VALUE self) {
+	return rv(self)->is_float();
+}
+
+static VALUE rvalue_to_f(VALUE self) {
+	return rv(self)->to_f();
+}
+
+static VALUE rvalue_is_undefined(VALUE self) {
+	return rv(self)->is_undefined();
+}
+
+static VALUE rvalue_get_attr(VALUE self,VALUE name) {
+	return rv(self)->get_attribute(name);
+}
+
+static VALUE rvalue_get_index(VALUE self,VALUE index) {
+	return rv(self)->get_index(index);
+}
+
+static VALUE rvalue_is_string(VALUE self) {
+	return rv(self)->is_string();
+}
+
+static VALUE rvalue_is_array(VALUE self) {
+	return rv(self)->is_array();
+}
+
+static VALUE rvalue_is_object(VALUE self) {
+	return rv(self)->is_object();
+}
+
+static VALUE rvalue_is_function(VALUE self) {
+	return rv(self)->is_function();
+}
+
+static VALUE rvalue_call(VALUE self, VALUE args) {
+	return rv(self)->call(args);
+}
+
+static VALUE rvalue_apply(VALUE self, VALUE to,VALUE args) {
+	return rv(self)->apply(to,args);
+}
+
+//------------ context ----------------------------------------------------------------
+
+inline H8* rc(VALUE self) {
+	H8 *prcxt;
+	Data_Get_Struct(self, H8, prcxt);
+	return prcxt;
+}
+
+static VALUE context_eval(VALUE self, VALUE script) {
+	H8* cxt = rc(self);
+	H8::Scope s(cxt);
+	return cxt->eval_to_ruby(StringValueCStr(script));
+}
+
+static VALUE context_set_var(VALUE self, VALUE name,VALUE value) {
+	rc(self)->set_var(name, value);
+	return Qnil;
+}
+
+static void context_free(void* ptr) {
+	delete (H8*) ptr;
+}
+
+VALUE h8::context_alloc(VALUE klass) {
+	H8 *h8 = new H8;
+	h8->self = Data_Wrap_Struct(klass, 0, context_free, h8);
+	return h8->self;
+}
+
+void init_v8() {
+	v8::V8::InitializeICU();
+	v8::Platform* platform = v8::platform::CreateDefaultPlatform();
+	v8::V8::InitializePlatform(platform);
+	v8::V8::Initialize();
+}
+
+void Init_h8(void) {
+	init_v8();
+
+	id_is_a = rb_intern("is_a?");
+
+	VALUE h8 = rb_define_module("H8");
+
+	context_class = rb_define_class_under(h8, "Context", rb_cObject);
+	rb_define_alloc_func(context_class, context_alloc);
+	rb_define_method(context_class, "eval", (ruby_method) context_eval, 1);
+	rb_define_method(context_class, "set_var", (ruby_method) context_set_var, 2);
+
+	value_class = rb_define_class_under(h8, "Value", rb_cObject);
+	rb_define_alloc_func(value_class, rvalue_alloc);
+	rb_define_method(value_class, "to_s", (ruby_method) rvalue_to_s, 0);
+	rb_define_method(value_class, "to_i", (ruby_method) rvalue_to_i, 0);
+	rb_define_method(value_class, "to_f", (ruby_method) rvalue_to_f, 0);
+	rb_define_method(value_class, "integer?", (ruby_method) rvalue_is_int, 0);
+	rb_define_method(value_class, "float?", (ruby_method) rvalue_is_float, 0);
+	rb_define_method(value_class, "string?", (ruby_method) rvalue_is_string,
+			0);
+	rb_define_method(value_class, "array?", (ruby_method) rvalue_is_array, 0);
+	rb_define_method(value_class, "object?", (ruby_method) rvalue_is_object, 0);
+	rb_define_method(value_class, "function?", (ruby_method) rvalue_is_function, 0);
+	rb_define_method(value_class, "undefined?", (ruby_method) rvalue_is_undefined,
+			0);
+	rb_define_method(value_class, "_get_attr", (ruby_method) rvalue_get_attr,
+			1);
+	rb_define_method(value_class, "_get_index", (ruby_method) rvalue_get_index,
+			1);
+	rb_define_method(value_class, "_call", (ruby_method) rvalue_call, 1);
+	rb_define_method(value_class, "_apply", (ruby_method) rvalue_apply, 2);
+
+	h8_exception = rb_define_class_under(h8, "Error", rb_eStandardError);
+
+}

data/ext/h8/object_wrap.h

@@ -0,0 +1,138 @@
+// Coypright iCodici SnC.
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+#ifndef SRC_OBJECT_WRAP_H_
+#define SRC_OBJECT_WRAP_H_
+
+#include "v8.h"
+#include <assert.h>
+
+
+namespace h8 {
+
+class ObjectWrap {
+ public:
+  ObjectWrap() {
+    refs_ = 0;
+  }
+
+
+  virtual ~ObjectWrap() {
+    if (persistent().IsEmpty())
+      return;
+    assert(persistent().IsNearDeath());
+    persistent().ClearWeak();
+    persistent().Reset();
+  }
+
+
+  template <class T>
+  static inline T* Unwrap(v8::Handle<v8::Object> handle) {
+    assert(!handle.IsEmpty());
+    assert(handle->InternalFieldCount() > 0);
+    // Cast to ObjectWrap before casting to T.  A direct cast from void
+    // to T won't work right when T has more than one base class.
+    void* ptr = handle->GetAlignedPointerFromInternalField(0);
+    ObjectWrap* wrap = static_cast<ObjectWrap*>(ptr);
+    return static_cast<T*>(wrap);
+  }
+
+
+  inline v8::Local<v8::Object> handle() {
+    return handle(v8::Isolate::GetCurrent());
+  }
+
+
+  inline v8::Local<v8::Object> handle(v8::Isolate* isolate) {
+    return v8::Local<v8::Object>::New(isolate, persistent());
+  }
+
+
+  inline v8::Persistent<v8::Object>& persistent() {
+    return handle_;
+  }
+
+
+ protected:
+  inline void Wrap(v8::Handle<v8::Object> handle) {
+    assert(persistent().IsEmpty());
+    assert(handle->InternalFieldCount() > 0);
+    handle->SetAlignedPointerInInternalField(0, this);
+    persistent().Reset(v8::Isolate::GetCurrent(), handle);
+    MakeWeak();
+  }
+
+
+  inline void MakeWeak(void) {
+    persistent().SetWeak(this, WeakCallback);
+    persistent().MarkIndependent();
+  }
+
+  /* Ref() marks the object as being attached to an event loop.
+   * Refed objects will not be garbage collected, even if
+   * all references are lost.
+   */
+  virtual void Ref() {
+    assert(!persistent().IsEmpty());
+    persistent().ClearWeak();
+    refs_++;
+  }
+
+  /* Unref() marks an object as detached from the event loop.  This is its
+   * default state.  When an object with a "weak" reference changes from
+   * attached to detached state it will be freed. Be careful not to access
+   * the object after making this call as it might be gone!
+   * (A "weak reference" means an object that only has a
+   * persistant handle.)
+   *
+   * DO NOT CALL THIS FROM DESTRUCTOR
+   */
+  virtual void Unref() {
+    assert(!persistent().IsEmpty());
+    assert(!persistent().IsWeak());
+    assert(refs_ > 0);
+    if (--refs_ == 0)
+      MakeWeak();
+  }
+
+  int refs_;  // ro
+
+ private:
+  static void WeakCallback(
+      const v8::WeakCallbackData<v8::Object, ObjectWrap>& data) {
+    v8::Isolate* isolate = data.GetIsolate();
+    v8::HandleScope scope(isolate);
+    ObjectWrap* wrap = data.GetParameter();
+    assert(wrap->refs_ == 0);
+    assert(wrap->handle_.IsNearDeath());
+    assert(
+        data.GetValue() == v8::Local<v8::Object>::New(isolate, wrap->handle_));
+    wrap->handle_.Reset();
+    delete wrap;
+  }
+
+  v8::Persistent<v8::Object> handle_;
+};
+
+}  // namespace node
+
+#endif  // SRC_NODE_OBJECT_WRAP_H_

data/ext/h8/ruby_wrap.h

@@ -0,0 +1,32 @@
+#ifndef __ruby_gate_h
+#define __ruby_gate_h
+
+#include "h8.h"
+#include "object_wrap.h"
+
+namespace h8 {
+
+    class RubyWrap : public ObjectWrap {
+    public:
+
+        RubyWrap(H8* ctx) : context(ctx) {
+            ctx->registerWrap(this);
+        }
+
+        public void setRubyInstance(VALUE instance) {
+            this->instance = instance;
+        }
+
+        virtual ~RubyWrap() {
+            context->unregisterWrap(this);
+        }
+
+    private:
+        H8 *context;
+        VALUE instance = Qnil;
+
+    };
+}
+
+
+#endif

data/hybrid8.gemspec

@@ -2,12 +2,14 @@
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'h8/version'
+require "rake/extensiontask"
+require 'rubygems/package_task'
 
-Gem::Specification.new do |spec|
+spec = Gem::Specification.new do |spec|
   spec.name          = "h8"
   spec.version       = H8::VERSION
   spec.authors       = ["sergeych"]
-  spec.email         = ["sergeych"]
+  spec.email         = ["real.sergeych@gmail.com"]
   spec.summary       = %q{Minimalistic and sane v8 bindings}
   spec.description   = %q{Should be more or less replacement for broken therubyracer gem and riny 2.1+ }
   spec.homepage      = ""
@@ -16,10 +18,27 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib', 'ext']
+
+  spec.extensions = FileList["ext/**/extconf.rb"]
+
+  spec.platform = Gem::Platform::RUBY
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "rspec", '>= 2.14.0'
+
+  # spec.add_dependency 'libv8'
+end
 
-  spec.add_dependency 'libv8'
+Gem::PackageTask.new(spec) do |pkg|
 end
+
+Rake::ExtensionTask.new "h8", spec do |ext|
+  ext.lib_dir  = "lib/h8"
+  ext.source_pattern = "*.{c,cpp}"
+  ext.gem_spec = spec
+end
+
+spec

data/lib/h8.rb

@@ -0,0 +1,9 @@
+require 'h8/version'
+require 'h8/context'
+require 'h8/h8'
+require 'h8/value'
+
+module H8
+
+  # Your code goes here...
+end

data/lib/h8/context.rb

@@ -0,0 +1,21 @@
+module H8
+  class Context
+    def initialize timout: nil, **kwargs
+      set **kwargs
+    end
+
+    def set **kwargs
+      kwargs.each { |name, value|
+        set_var(name.to_s, value)
+      }
+    end
+
+    def []= name, value
+      set name => value
+    end
+
+    def self.eval script
+      Context.new.eval script
+    end
+  end
+end

data/lib/h8/value.rb

@@ -0,0 +1,77 @@
+module H8
+
+  # Wrapper for javascript objects.
+  #
+  # Important: when accessin fields of the object, respond_to? will not work due to
+  # js notation, instead, check the returned value to be value.undefined?
+  class Value
+
+    include Comparable
+
+    def inspect
+      "<H8::Value #{to_s}>"
+    end
+
+    # Get js object attribute by its name or index (should be Fixnum instance). It always
+    # return H8::Value instance, check it to (not) be undefined? to see if there is such attribute
+    def [] name_index
+      name_index.is_a?(Fixnum) ? _get_index(name_index) : _get_attr(name_index)
+    end
+
+    # Optimized JS member access. Do not yet support calls!
+    # use only to get fields
+    def method_missing(method_sym, *arguments, &block)
+      name = method_sym.to_s
+      instance_eval <<-End
+              def #{name} *args, **kwargs
+                res = _get_attr('#{name}')
+                res.function? ? res.apply(res,*args) : res
+              end
+      End
+      send method_sym, *arguments
+    end
+
+    # def each_key
+    #   p eval("Object.keys(this)");
+    # end
+    #
+    # def keys
+    #   cxt = self._context
+    #   cxt['__self'] =
+    # end
+
+    def <=> other
+      other = other.to_ruby if other.is_a?(H8::Value)
+      to_ruby <=> other
+    end
+
+    def call *args
+      _call args
+    end
+
+    def apply to, *args
+      _apply to, args
+    end
+
+    def to_ary
+      raise Error, 'Is not an array' unless array?
+      to_ruby
+    end
+
+    def to_ruby
+      case
+        when integer?
+          to_i
+        when string?
+          to_s
+        when float?
+          to_f
+        when array?
+          _get_attr('length').to_i.times.map { |i| _get_index(i).to_ruby }
+        else
+          raise Error, "Dont know how to convert H8::Value"
+      end
+    end
+  end
+
+end