rucy 0.1.11 → 0.1.16

data/include/rucy/module.h.erb

@@ -41,7 +41,7 @@ namespace Rucy
 			void extend_module (Value module);
 
 %			[
-%				'define_function',
+%				'define_module_function',
 %				'define_method',
 %				'define_private_method',
 %				'define_singleton_method',

data/include/rucy/value.h.erb

@@ -41,6 +41,8 @@ namespace Rucy
 
 			bool is_f () const;
 
+			bool is_num () const;
+
 			bool is_s () const;
 
 			bool is_sym () const;
@@ -120,9 +122,9 @@ namespace Rucy
 
 			Value unshift (Value obj);
 
-			      Value& operator [] (int i);
+			      Value& operator [] (size_t i);
 
-			const Value& operator [] (int i) const;
+			const Value& operator [] (size_t i) const;
 
 			// String
 
@@ -134,6 +136,8 @@ namespace Rucy
 
 			int size () const;
 
+			bool empty () const;
+
 		protected:
 
 			RubyValue val;
@@ -144,7 +148,9 @@ namespace Rucy
 	class GlobalValue : public Value
 	{
 
-		typedef Value Super;
+		typedef       Value Super;
+
+		typedef GlobalValue This;
 
 		public:
 
@@ -170,24 +176,24 @@ namespace Rucy
 
 			GlobalValue (const Value& v, bool gc = false);
 
-			GlobalValue (const GlobalValue& obj, bool gc = false);
+			GlobalValue (const This& obj, bool gc = false);
 
 			GlobalValue& operator = (const Value& v);
 
+			GlobalValue& operator = (const This& obj);
+
 			~GlobalValue ();
 
-			void gc (bool enable) const;
+			void  enable_gc () const;
 
-		private:
+			void disable_gc () const;
 
-			mutable short gc_disable_count;
+		private:
 
-			mutable bool gc_guarded;
+			mutable int gc_disable_count;
 
 			void init (bool gc);
 
-			void update_guard () const;
-
 	};// GlobalValue
 
 
@@ -224,21 +230,30 @@ namespace Rucy
 	Value value (const char* s, size_t len);
 
 	Value value (size_t size, const Value* array);
-
-	Value value (void* ptr);
-%	(1..10).each do |n|
+%	(1..16).each do |n|
 
 	Value array (<%= params(n, ', ') {|i| "Value v#{i}"} %>);
 %	end
 
 
-	template <typename T>        T value_to (Value obj, bool convert = true);
+	template <typename T> T
+	value_to (Value obj, bool convert = true);
 
-	template <typename T> inline T       to (Value obj, bool convert = true)
+	template <typename T> inline T
+	to       (Value obj, bool convert = true)
 	{
 		return value_to<T>(obj, convert);
 	}
 
+	template <typename T> T
+	value_to (int argc, const Value* argv, bool convert = true);
+
+	template <typename T> inline T
+	to       (int argc, const Value* argv, bool convert = true)
+	{
+		return value_to<T>(argc, argv, convert);
+	}
+
 	template <typename T> inline T Value::as (bool convert) const
 	{
 		return value_to<T>(*this, convert);

data/lib/rucy/module.rb

@@ -6,6 +6,8 @@ module Rucy
 
   module Module
 
+    module_function
+
     def name ()
       super.split('::')[-2]
     end
@@ -15,10 +17,10 @@ module Rucy
     end
 
     def root_dir (path = '')
-      File.expand_path "../../../#{path}", __FILE__
+      File.expand_path "../../#{path}", __dir__
     end
 
-    def include_dir ()
+    def inc_dir ()
       root_dir 'include'
     end
 
@@ -26,23 +28,6 @@ module Rucy
       root_dir 'lib'
     end
 
-    def task_dir ()
-      root_dir 'task'
-    end
-
-    def load_tasks (*names)
-      if names.empty?
-        Dir["#{task_dir}/**/*.rake"].each {|path| load path}
-      else
-        names.each do |name|
-          path = "#{task_dir}/#{name}.rake"
-          load path if File.exist? path
-        end
-      end
-    end
-
-    extend self
-
   end# Module
 
 

data/lib/rucy/rake.rb

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+
+
+require 'xot/rake'
+
+
+module Rucy
+
+
+  module Rake
+
+
+    def rdoc ()
+      env :RDOC, 'rdoc'# 'yardoc'
+    end
+
+    def rucy2rdoc ()
+      env :RUCY2RDOC, 'rucy2rdoc'
+    end
+
+    def generate_documents ()
+      rdocdir = ".doc/#{ext_dir}"
+      srcs    = FileList["#{ext_dir}/**/*.{#{src_exts.join ','}}"]
+      rdocs   = Hash[srcs.map{|path| [path, "#{rdocdir}/#{File.basename path}"]}]
+      out     = "#{doc_dir}/index.html"
+
+      alias_task :doc   => out
+      alias_task :clean => 'doc:clean'
+
+      namespace :doc do
+        desc "build documents"
+        file out => rdocs.values do
+          sh %( #{rdoc} #{rdocs.values.join ' '} )
+        end
+
+        rdocs.each do |(src, rdoc)|
+          file rdoc => [src, rdocdir] do
+            sh %( #{rucy2rdoc} #{src} > #{rdoc} )
+          end
+        end
+
+        directory rdocdir
+
+        task :clean do
+          sh %( rm -rf #{rdocdir} #{rdocs.values.join ' '} )
+        end
+      end
+    end
+
+
+  end# Rake
+
+
+end# Rucy
+
+
+include Rucy::Rake
+
+
+File.expand_path('../../bin', __dir__).tap do |path|
+  ENV['PATH'] += ":#{path}" unless ENV['PATH'].split(':').include?(path)
+end

data/rucy.gemspec

@@ -21,16 +21,14 @@ Gem::Specification.new do |s|
   s.description = 'This library helps you to develop Ruby Extension by C++.'
   s.version     = mod.version
 
-  s.authors  = %w[snori]
-  s.email    = 'snori@xord.org'
+  s.authors  = %w[xordog]
+  s.email    = 'xordog@gmail.com'
   s.homepage = "https://github.com/xord/rucy"
 
   s.platform              = Gem::Platform::RUBY
-  s.required_ruby_version = '>=1.9.0'
+  s.required_ruby_version = '~> 2'
 
-  s.add_runtime_dependency 'rake'
-  s.add_runtime_dependency 'xot'
-  s.add_development_dependency 'gemcutter'
+  s.add_runtime_dependency 'xot', '~> 0.1'
 
   s.files            = `git ls-files`.split $/
   s.executables      = s.files.grep(%r{^bin/}) {|f| File.basename f}

data/src/module.cpp.erb

@@ -58,7 +58,7 @@ namespace Rucy
 	}
 
 %	[
-%		['define_function',         'rb_define_module_function'],
+%		['define_module_function',  'rb_define_module_function'],
 %		['define_method',           'rb_define_method'],
 %		['define_private_method',   'rb_define_private_method'],
 %		['define_singleton_method', 'rb_define_singleton_method']

data/src/value.cpp.erb

@@ -5,6 +5,7 @@
 #include <assert.h>
 #include "rucy/function.h"
 #include "rucy/exception.h"
+#include "rucy/debug.h"
 
 
 namespace Rucy
@@ -101,6 +102,12 @@ namespace Rucy
 		return RB_FLOAT_TYPE_P(val) || is_kind_of(rb_cFloat);
 	}
 
+	bool
+	Value::is_num () const
+	{
+		return is_i() || is_f();
+	}
+
 	bool
 	Value::is_s () const
 	{
@@ -325,13 +332,13 @@ namespace Rucy
 	}
 
 	Value&
-	Value::operator [] (int i)
+	Value::operator [] (size_t i)
 	{
 		return as_array()[i];
 	}
 
 	const Value&
-	Value::operator [] (int i) const
+	Value::operator [] (size_t i) const
 	{
 		return const_cast<Value*>(this)->operator[](i);
 	}
@@ -339,7 +346,7 @@ namespace Rucy
 	const char*
 	Value::c_str () const
 	{
-		return as<const char*>(true);
+		return as_s(true);
 	}
 
 	static int
@@ -367,6 +374,12 @@ namespace Rucy
 		return get_length(*this, size);
 	}
 
+	bool
+	Value::empty () const
+	{
+		return size() <= 0;
+	}
+
 
 	GlobalValue::GlobalValue ()
 	{
@@ -433,7 +446,7 @@ namespace Rucy
 		init(gc_);
 	}
 
-	GlobalValue::GlobalValue (const GlobalValue& obj, bool gc_)
+	GlobalValue::GlobalValue (const This& obj, bool gc_)
 	:	Super(obj)
 	{
 		init(gc_);
@@ -443,50 +456,41 @@ namespace Rucy
 	GlobalValue::operator = (const Value& v)
 	{
 		Super::operator=(v);
-		update_guard();
+		return *this;
+	}
+
+	GlobalValue&
+	GlobalValue::operator = (const This& obj)
+	{
+		Super::operator=(obj);
 		return *this;
 	}
 
 	GlobalValue::~GlobalValue ()
 	{
-		while (gc_guarded) gc(true);
+		if (gc_disable_count > 0)
+			rb_gc_unregister_address(&val);
 	}
 
 	void
-	GlobalValue::gc (bool enable) const
+	GlobalValue::enable_gc () const
 	{
-		gc_disable_count += enable ? -1 : +1;
-		update_guard();
+		if (--gc_disable_count == 0)
+			rb_gc_unregister_address(const_cast<RubyValue*>(&val));
 	}
 
 	void
-	GlobalValue::init (bool gc_)
+	GlobalValue::disable_gc () const
 	{
-		gc_disable_count = 0;
-		gc_guarded       = false;
-		if (!gc_) gc(false);
+		if (++gc_disable_count == 1)
+			rb_gc_register_address(const_cast<RubyValue*>(&val));
 	}
 
 	void
-	GlobalValue::update_guard () const
+	GlobalValue::init (bool gc_)
 	{
-		assert(gc_disable_count >= 0);
-
-		if (IMMEDIATE_P(val))
-		{
-			if (gc_guarded) rb_gc_unregister_address((RubyValue*) &val);
-			gc_guarded = false;
-		}
-		else if (gc_disable_count > 0)
-		{
-			if (!gc_guarded) rb_gc_register_address((RubyValue*) &val);
-			gc_guarded = true;
-		}
-		else
-		{
-			if (gc_guarded) rb_gc_unregister_address((RubyValue*) &val);
-			gc_guarded = false;
-		}
+		gc_disable_count = 0;
+		if (!gc_) disable_gc();
 	}
 
 
@@ -591,16 +595,7 @@ namespace Rucy
 	{
 		return Value(size, array);
 	}
-
-	Value
-	value (void* ptr)
-	{
-		if (ptr)
-			argument_error(__FILE__, __LINE__, "Rucy::value(void*) can take only (void*) NULL.");
-
-		return nil();
-	}
-%	(1..10).each do |n|
+%	(1..16).each do |n|
 
 	Value
 	array (<%= params(n, ', ') {|i| "Value v#{i}"} %>)

data/test/test_class.rb

@@ -14,10 +14,6 @@ class Temp < Rucy::Tester::Sub
     "Temp::name_overridable"
   end
 
-  def name_overridable_faster ()
-    "Temp::name_overridable_faster"
-  end
-
 end# Temp
 
 
@@ -94,7 +90,7 @@ class TestClass < Test::Unit::TestCase
     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"!
+    assert_equal "Sub::name",  temp    .call_name# "Sub" instead of "Temp"!
   end
 
   def test_call_name_overridable ()
@@ -105,37 +101,9 @@ class TestClass < Test::Unit::TestCase
     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 simple_objs (name, n = 10) ([nil] * n).map {SimpleObj.new name} end
-    def gc (n = 10) n.times {GC.start}; print '' end
+    def gc () GC.start end
     rt = Rucy::Tester
 
     gc