rucy 0.1.3 → 0.1.4

data/src/rucy.cpp

@@ -33,10 +33,10 @@ namespace Rucy
 		SYMBOL(klass, "class");
 		SYM(name);
 		String message = stringf(
-			"object is instance of %s, bug %s is expected.",
+			"object is instance of %s, but %s is expected.",
 			obj(klass)(name).c_str(), class_(name).c_str());
 
-		throw RubyException(rb_eTypeError, message);
+		type_error(message.c_str());
 #endif
 	}
 

data/src/symbol.cpp

@@ -3,6 +3,7 @@
 
 
 #include <rucy/rucy.h>
+#include <rucy/value.h>
 
 
 namespace Rucy
@@ -19,6 +20,11 @@ namespace Rucy
 	{
 	}
 
+	Symbol::Symbol (const Value& value)
+	:	id_(value.as_sym().id())
+	{
+	}
+
 	Symbol::Symbol (const char* str)
 	:	id_(rb_intern(str))
 	{
@@ -30,6 +36,12 @@ namespace Rucy
 		return id_;
 	}
 
+	VALUE
+	Symbol::value () const
+	{
+		return id_ != 0 ? ID2SYM(id_) : Qnil;
+	}
+
 	const char*
 	Symbol::c_str () const
 	{
@@ -47,5 +59,17 @@ namespace Rucy
 		return !operator bool();
 	}
 
+	bool
+	operator == (const Symbol& lhs, const Symbol& rhs)
+	{
+		return lhs.id_ == rhs.id_;
+	}
+
+	bool
+	operator != (const Symbol& lhs, const Symbol& rhs)
+	{
+		return !operator==(lhs, rhs);
+	}
+
 
 }// Rucy

data/src/value.cpp.erb

@@ -2,6 +2,7 @@
 #include "rucy/value.h"
 
 
+#include <assert.h>
 #include <rucy/rucy.h>
 #include <rucy/function.h>
 #include <rucy/exception.h>
@@ -37,12 +38,12 @@ namespace Rucy
 	}
 
 	Value::Value (const char* s, bool tainted)
-	:	v(tainted ? rb_tainted_str_new2(s) : rb_str_new2(s))
+	:	v(!s ? Qnil : tainted ? rb_tainted_str_new2(s) : rb_str_new2(s))
 	{
 	}
 
 	Value::Value (const char* s, size_t len, bool tainted)
-	:	v(tainted ? rb_tainted_str_new(s, len) : rb_str_new(s, len))
+	:	v(!s ? Qnil : tainted ? rb_tainted_str_new(s, len) : rb_str_new(s, len))
 	{
 	}
 
@@ -94,9 +95,9 @@ namespace Rucy
 	get_object_size (Value obj, Symbol method)
 	{
 		if (obj.type() == T_STRING)
-			return RSTRING_LEN(obj.value());
+			return (int) RSTRING_LEN(obj.value());
 		else if (obj.type() == T_ARRAY)
-			return RARRAY_LEN(obj.value());
+			return (int) RARRAY_LEN(obj.value());
 		else
 			return obj.call(method);
 	}
@@ -147,6 +148,30 @@ namespace Rucy
 		return call(to_sym);
 	}
 
+	int
+	Value::as_i (bool convert) const
+	{
+		return to<int>(*this, convert);
+	}
+
+	double
+	Value::as_f (bool convert) const
+	{
+		return to<double>(*this, convert);
+	}
+
+	const char*
+	Value::as_s (bool convert) const
+	{
+		return to<const char*>(*this, convert);
+	}
+
+	Symbol
+	Value::as_sym (bool convert) const
+	{
+		return to<Symbol>(*this, convert);
+	}
+
 	bool
 	Value::is_i () const
 	{
@@ -177,28 +202,10 @@ namespace Rucy
 		return is_kind_of(rb_cArray);
 	}
 
-	int
-	Value::as_i (bool convert) const
-	{
-		return to<int>(*this, convert);
-	}
-
-	double
-	Value::as_f (bool convert) const
-	{
-		return to<double>(*this, convert);
-	}
-
-	const char*
-	Value::as_s (bool convert) const
-	{
-		return to<const char*>(*this, convert);
-	}
-
-	Symbol
-	Value::as_sym (bool convert) const
+	bool
+	Value::is_nil () const
 	{
-		return to<Symbol>(*this, convert);
+		return NIL_P(v);
 	}
 
 %	["call", "operator ()"].each do |op|
@@ -302,6 +309,122 @@ namespace Rucy
 	}
 
 
+	GlobalValue::GlobalValue ()
+	{
+		init(false);
+	}
+
+	GlobalValue::GlobalValue (bool b, bool gc_)
+	:	Super(b)
+	{
+		init(gc_);
+	}
+
+	GlobalValue::GlobalValue (int i, bool gc_)
+	:	Super(i)
+	{
+		init(gc_);
+	}
+
+	GlobalValue::GlobalValue (float f, bool gc_)
+	:	Super(f)
+	{
+		init(gc_);
+	}
+
+	GlobalValue::GlobalValue (double d, bool gc_)
+	:	Super(d)
+	{
+		init(gc_);
+	}
+
+	GlobalValue::GlobalValue (const char* s, bool tainted, bool gc_)
+	:	Super(s, tainted)
+	{
+		init(gc_);
+	}
+
+	GlobalValue::GlobalValue (const char* s, size_t len, bool tainted, bool gc_)
+	:	Super(s, len, tainted)
+	{
+		init(gc_);
+	}
+
+	GlobalValue::GlobalValue (size_t size, const Value* values, bool gc_)
+	:	Super(size, values)
+	{
+		init(gc_);
+	}
+
+	GlobalValue::GlobalValue (VALUE v, bool gc_)
+	:	Super(v)
+	{
+		init(gc_);
+	}
+
+	GlobalValue::GlobalValue (const Value& obj, bool gc_)
+	:	Super(obj)
+	{
+		init(gc_);
+	}
+
+	GlobalValue::GlobalValue (const GlobalValue& obj, bool gc_)
+	:	Super(obj)
+	{
+		init(gc_);
+	}
+
+	GlobalValue&
+	GlobalValue::operator = (const Value& obj)
+	{
+		Super::operator=(obj);
+		update_guard();
+		return *this;
+	}
+
+	GlobalValue::~GlobalValue ()
+	{
+		while (gc_guarded) gc(true);
+	}
+
+	void
+	GlobalValue::gc (bool enable)
+	{
+		gc_disable_count += enable ? -1 : +1;
+		update_guard();
+	}
+
+	void
+	GlobalValue::init (bool gc_)
+	{
+		gc_disable_count = 0;
+		gc_guarded       = false;
+		if (!gc_) gc(false);
+	}
+
+	void
+	GlobalValue::update_guard ()
+	{
+		assert(gc_disable_count >= 0);
+
+		if (IMMEDIATE_P(v))
+		{
+			if (gc_guarded) rb_gc_unregister_address(&v);
+			gc_guarded = false;
+		}
+		else if (gc_disable_count > 0)
+		{
+			if (!gc_guarded) rb_gc_register_address(&v);
+			gc_guarded = true;
+		}
+		else
+		{
+			if (gc_guarded) rb_gc_unregister_address(&v);
+			gc_guarded = false;
+		}
+	}
+
+
 	Value
 	value (bool b)
 	{
@@ -404,5 +527,18 @@ namespace Rucy
 		return ID2SYM(sym.id());
 	}
 
+	Value
+	value (void* ptr)
+	{
+		if (ptr) argument_error("Rucy::value(void*) can take only (void*) NULL.");
+		return Qnil;
+	}
+
+	Value
+	nil ()
+	{
+		return Qnil;
+	}
+
 
 }// Rucy

data/task/doc.rake

@@ -0,0 +1,50 @@
+# -*- mode: ruby; coding: utf-8 -*-
+
+
+task :doc => 'doc:build'
+
+%w[clean rdoc].each do |t|
+  task t.intern => "doc:#{t}"
+end
+
+
+namespace :doc do
+
+
+  mod       = MODULE
+  name      = env :NAME, MODULE.name.downcase
+  extdir    = env :EXTDIR,    'ext'
+  docdir    = env :DOCDIR,    'doc'
+  rdoc      = env :RDOC,      'rdoc'# 'yardoc'
+  rucy2rdoc = env :RUCY2RDOC, 'rucy2rdoc'
+
+  srcdir  = "#{extdir}/#{name}"
+  rdocdir = ".doc/#{srcdir}"
+
+  srcs  = FileList["#{srcdir}/**/*.cpp"]
+  rdocs = Hash[srcs.map{|path| [path, "#{rdocdir}/#{File.basename path}"]}]
+  out   = "#{docdir}/index.html"
+
+
+  task :build => out
+
+  task :clean do
+    sh %( rm -rf #{docdir} #{rdocs.values.join ' '} )
+  end
+
+  task :rdoc => rdocs.values
+
+  file out => :rdoc do
+    sh %( #{rdoc} #{rdocs.values.join ' '} )
+  end
+
+  rdocs.each do |(cpp, rdoc)|
+    file rdoc => [cpp, rdocdir] do
+      sh %( #{rucy2rdoc} #{cpp} > #{rdoc} )
+    end
+  end
+
+  directory rdocdir
+
+
+end# :doc

data/test/helpers.rb

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+
+
+require 'bundler/setup'
+require 'test/unit'
+require 'rucy'
+require 'rucy/tester'

data/test/test_class.rb

@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helpers'
+
+
+class Temp < Rucy::Tester::Sub
+
+  def name ()
+    "Temp::name"
+  end
+
+  def name_overridable ()
+    "Temp::name_overridable"
+  end
+
+  def name_overridable_faster ()
+    "Temp::name_overridable_faster"
+  end
+
+end# Temp
+
+
+class TestClass < Test::Unit::TestCase
+
+  include Rucy::Tester
+
+  def base (*args)
+    Base.new *args
+  end
+
+  def sub (*args)
+    Sub.new *args
+  end
+
+  def temp (*args)
+    Temp.new *args
+  end
+
+  def base_raw (*args)
+    Base.new_raw *args
+  end
+
+  def sub_raw (*args)
+    Sub.new_raw *args
+  end
+
+  def test_is_kind_of_base ()
+    assert_kind_of Base, base
+    assert_kind_of Base, base_raw
+
+    assert_kind_of Base, sub
+    assert_kind_of Base, sub_raw
+    assert_kind_of Sub,  sub
+    assert_kind_of Sub,  sub_raw
+
+    assert_kind_of Base, temp
+    assert_kind_of Sub,  temp
+    assert_kind_of Temp, temp
+
+    assert !base     .kind_of?(Sub)
+    assert !base_raw .kind_of?(Sub)
+    assert !base     .kind_of?(Temp)
+    assert !base_raw .kind_of?(Temp)
+
+    assert !sub    .kind_of?(Temp)
+    assert !sub_raw.kind_of?(Temp)
+  end
+
+  def test_name ()
+    assert_equal "Base::name", base    .name
+    assert_equal "Base::name", base_raw.name
+    assert_equal "Sub::name",  sub     .name
+    assert_equal "Sub::name",  sub_raw .name
+    assert_equal "Temp::name", temp    .name
+  end
+
+  def test_name_overridable ()
+    assert_equal "Base::name_overridable", base    .name_overridable
+    assert_equal "Base::name_overridable", base_raw.name_overridable
+    assert_equal "Sub::name_overridable",  sub     .name_overridable
+    assert_equal "Sub::name_overridable",  sub_raw .name_overridable
+    assert_equal "Temp::name_overridable", temp    .name_overridable
+  end
+
+  def test_call_name ()
+    assert_equal "Base::name", base    .call_name
+    assert_equal "Base::name", base_raw.call_name
+    assert_equal "Sub::name",  sub     .call_name
+    assert_equal "Sub::name",  sub_raw .call_name
+    assert_equal "Sub::name",  temp    .call_name # returns "Sub" not "Temp"!
+  end
+
+  def test_call_name_overridable ()
+    assert_equal "Base::name_overridable", base    .call_name_overridable
+    assert_equal "Base::name_overridable", base_raw.call_name_overridable
+    assert_equal "Sub::name_overridable",  sub     .call_name_overridable
+    assert_equal "Sub::name_overridable",  sub_raw .call_name_overridable
+    assert_equal "Temp::name_overridable", temp    .call_name_overridable
+  end
+
+  class X < Sub; end
+
+  def test_is_overridden ()
+    m = :name_overridable_faster
+    def is_overridden (o) o.is_name_overridable_faster_overridden; end
+
+    assert_equal true, is_overridden(temp)
+
+    o = X.new
+    assert_equal false, is_overridden(o)
+    def o.name_overridable_faster () end
+    assert_equal true,  is_overridden(o)
+
+    o = X.new
+    assert_equal false, is_overridden(o)
+    eval "class X; def #{m}; end; end"
+    assert_equal true,  is_overridden(o)
+    eval "class X; remove_method :#{m}; end"
+    assert_equal false, is_overridden(o)
+
+    o = X.new
+    assert_equal false, is_overridden(o)
+    X.send(:define_method, m) {}
+    assert_equal true,  is_overridden(o)
+    X.send :remove_method, m
+    assert_equal false, is_overridden(o)
+  end
+
+  def test_gc ()
+    def gc () 10.times {GC.start} end
+    rt = Rucy::Tester
+
+    gc
+    rt.clear_logs
+
+    o = RubyObj.new
+    assert_equal 'RubyObj()', last_log
+    gc
+    assert_equal 'RubyObj()', last_log
+    o = nil
+    gc
+    assert_equal '~RubyObj()', last_log
+
+    gc
+    rt.clear_logs
+
+    o = RubyObj.new
+    assert_equal 'RubyObj()', last_log
+    RubyObj.set_ref o
+    gc
+    assert_equal 'RubyObj()', last_log
+    o = nil
+    gc
+    assert_equal 'RubyObj()', last_log
+    RubyObj.clear_ref
+    gc
+    assert_equal '~RubyObj()', last_log
+  end
+
+end# TestClass

data/test/test_exception.rb

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helpers'
+
+
+class TestException < Test::Unit::TestCase
+
+  include Rucy::Tester
+
+  def test_raise_ruby_exception ()
+    assert_raise(StandardError) {raise_ruby_exception}
+  end
+
+  def test_raise_in_eval ()
+    assert_raise(RuntimeError) {raise_in_eval}
+  end
+
+  def test_throw_std_exception ()
+    assert_raise(Rucy::NativeError) {throw_std_exception}
+  end
+
+  def test_throw_std_runtime_error ()
+    assert_raise(Rucy::NativeError) {throw_std_runtime_error}
+  end
+
+  def test_throw_custom_exception ()
+    assert_raise(Rucy::NativeError) {throw_custom_exception}
+  end
+
+  def test_throw_std_string ()
+    assert_raise(Rucy::NativeError) {throw_std_string}
+  end
+
+  def test_throw_cstring ()
+    assert_raise(Rucy::NativeError) {throw_cstring}
+  end
+
+end# TestException

data/test/test_function.rb

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helpers'
+
+
+class TestFunction < Test::Unit::TestCase
+
+  include Rucy::Tester
+
+  def test_do_nothing_returns_nil ()
+    assert_equal nil, do_nothing
+  end
+
+  def test_returns_nil ()
+    assert_equal nil, return_nil
+  end
+
+  def test_return_int ()
+    assert_kind_of Integer, return_int
+  end
+
+  def test_return_float ()
+    assert_kind_of Float, return_float
+  end
+
+  def test_return_string ()
+    assert_kind_of String, return_string
+  end
+
+end# TestFunction

data/test/test_struct.rb

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helpers'
+
+
+class TestStruct < Test::Unit::TestCase
+
+  def setup ()
+    @x = Rucy::Tester::Struct.new
+  end
+
+  def test_default_value_is_0 ()
+    assert_equal 0, @x.num
+  end
+
+  def test_get_set_num ()
+    @x.num = 1
+    assert_equal 1, @x.num
+  end
+
+  def test_dup ()
+    assert_equal 0, @x.num
+    x = @x.dup
+    @x.num = 1
+    assert_equal 1, @x.num
+    assert_equal 0, x.num
+  end
+
+end# TestStruct

data/test/test_value.rb

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helpers'
+
+
+class TestFunction < Test::Unit::TestCase
+
+  include Rucy::Tester
+
+  def test_to_value ()
+    assert_equal true, true_to_value
+    assert_equal false, false_to_value
+    assert_equal nil, null_to_value
+    assert_equal nil, nil_value
+  end
+
+end# TestFunction