extpp 0.0.1

data/test/fixtures/class/class.cpp

@@ -0,0 +1,46 @@
+#include <ruby.hpp>
+
+namespace {
+  VALUE rb_hello(VALUE self) {
+    return rb_str_new_cstr("Hello");
+  }
+
+  VALUE rb_named_hello(int argc, VALUE *argv, VALUE self) {
+    VALUE rb_name;
+    rb_scan_args(argc, argv, "10", &rb_name);
+    return rb_str_plus(rb_str_new_cstr("Hello "), rb_name);
+  }
+}
+
+extern "C" void
+Init_class(void)
+{
+  rb::Class("Greeting").
+    define_method("hello", [](VALUE self) {
+        return rb_str_new_cstr("Hello");
+      }).
+    enable_lazy_define_method().
+    define_method("hello_lazy", [](VALUE self) {
+        return rb_str_new_cstr("Hello");
+      }).
+    define_method("hello_defined", rb_hello);
+
+  rb::Class("NamedGreeting").
+    define_method("hello", [](VALUE self, int argc, VALUE *argv) {
+        VALUE rb_name;
+        rb_scan_args(argc, argv, "10", &rb_name);
+        return rb_str_plus(rb_str_new_cstr("Hello "), rb_name);
+      }).
+    define_method("hello_compatible", [](int argc, VALUE *argv, VALUE self) {
+        VALUE rb_name;
+        rb_scan_args(argc, argv, "10", &rb_name);
+        return rb_str_plus(rb_str_new_cstr("Hello "), rb_name);
+      }).
+    enable_lazy_define_method().
+    define_method("hello_lazy", [](VALUE self, int argc, VALUE *argv) {
+        VALUE rb_name;
+        rb_scan_args(argc, argv, "10", &rb_name);
+        return rb_str_plus(rb_str_new_cstr("Hello "), rb_name);
+      }).
+    define_method("hello_defined", rb_named_hello);
+}

data/test/fixtures/class/extconf.rb

@@ -0,0 +1,4 @@
+require "mkmf"
+require "extpp"
+
+create_makefile("class")

data/test/fixtures/object/extconf.rb

@@ -0,0 +1,4 @@
+require "mkmf"
+require "extpp"
+
+create_makefile("object")

data/test/fixtures/object/object.cpp

@@ -0,0 +1,78 @@
+#include <ruby.hpp>
+
+extern "C" void
+Init_object(void)
+{
+  rb::Class("ObjectMethods").
+    define_method("to_bool_true", [](VALUE self) {
+        rb::Object object(Qtrue);
+        if (object) {
+          return Qtrue;
+        } else {
+          return Qfalse;
+        }
+      }).
+    define_method("to_bool_false", [](VALUE self) {
+        rb::Object object(Qfalse);
+        if (object) {
+          return Qtrue;
+        } else {
+          return Qfalse;
+        }
+      }).
+    define_method("to_bool_nil", [](VALUE self) {
+        rb::Object object(Qnil);
+        if (object) {
+          return Qtrue;
+        } else {
+          return Qfalse;
+        }
+      }).
+    define_method("to_ruby", [](int argc, VALUE *argv, VALUE self) {
+        VALUE rb_object;
+        rb_scan_args(argc, argv, "1", &rb_object);
+        rb::Object object(rb_object);
+        return static_cast<VALUE>(object);
+      }).
+    define_method("send_no_arguments", [](int argc, VALUE *argv, VALUE self) {
+        VALUE rb_receiver;
+        VALUE rb_method_name;
+        rb_scan_args(argc, argv, "2", &rb_receiver, &rb_method_name);
+        rb::Object receiver(rb_receiver);
+        rb::Object method_name(rb_method_name);
+        auto result = receiver.send(method_name);
+        return static_cast<VALUE>(result);
+      }).
+    define_method("send_two_arguments", [](int argc, VALUE *argv, VALUE self) {
+        VALUE rb_receiver;
+        VALUE rb_method_name;
+        VALUE rb_arg1;
+        VALUE rb_arg2;
+        rb_scan_args(argc, argv, "4",
+                     &rb_receiver,
+                     &rb_method_name,
+                     &rb_arg1,
+                     &rb_arg2);
+        rb::Object receiver(rb_receiver);
+        rb::Object method_name(rb_method_name);
+        auto result = receiver.send(method_name, {rb_arg1, rb_arg2});
+        return static_cast<VALUE>(result);
+      }).
+    define_method("send_block", [](int argc, VALUE *argv, VALUE self) {
+        VALUE rb_receiver;
+        VALUE rb_method_name;
+        rb_scan_args(argc, argv, "2",
+                     &rb_receiver,
+                     &rb_method_name);
+        rb::Object receiver(rb_receiver);
+        rb::Object method_name(rb_method_name);
+        auto result = receiver.send(method_name,
+                                    {},
+                                    [](VALUE rb_n) -> VALUE {
+                                      auto n = rb::Object(rb_n);
+                                      auto n_raw = rb::cast<int32_t>(n);
+                                      return rb::cast<rb::Object>(n_raw * n_raw);
+                                    });
+        return static_cast<VALUE>(result);
+      });
+}

data/test/helper.rb

@@ -0,0 +1,9 @@
+require "test-unit"
+
+module Helper
+  module Fixture
+    def fixture_path(*components)
+      File.join(__dir__, "fixtures", *components)
+    end
+  end
+end

data/test/run-test.rb

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+$VERBOSE = true
+
+require "pathname"
+
+base_dir = Pathname.new(__dir__).parent.expand_path
+
+ext_dir = base_dir + "ext" + "extpp"
+lib_dir = base_dir + "lib"
+test_dir = base_dir + "test"
+
+Dir.chdir(ext_dir.to_s) do
+  if File.exist?("Makefile")
+    system("make > /dev/null") or exit(false)
+  end
+end
+
+$LOAD_PATH.unshift(lib_dir.to_s)
+
+require_relative "helper"
+
+exit(Test::Unit::AutoRunner.run(true, test_dir.to_s))

data/test/test-cast.rb

@@ -0,0 +1,42 @@
+class CastTest < Test::Unit::TestCase
+  extend Helper::Fixture
+
+  class << self
+    def startup
+      lib_dir = File.join(__dir__, "..", "lib")
+      Dir.chdir(fixture_path("cast")) do
+        system(RbConfig.ruby, "-w", "-I", lib_dir, "extconf.rb")
+        system("make")
+      end
+      require fixture_path("cast", "cast")
+    end
+  end
+
+  def setup
+    @caster = Caster.new
+  end
+
+  def test_int32
+    assert_equal(-(2 ** 31),
+                 @caster.cast_int32(-(2 ** 31)))
+  end
+
+  def test_int64
+    assert_equal(-(2 ** 63),
+                 @caster.cast_int64(-(2 ** 63)))
+  end
+
+  def test_uint32
+    assert_equal(2 ** 32 - 1,
+                 @caster.cast_uint32(2 ** 32 - 1))
+  end
+
+  def test_uint64
+    assert_equal(2 ** 64 - 1,
+                 @caster.cast_uint64(2 ** 64 - 1))
+  end
+
+  def test_string
+    assert_equal("Hello", @caster.cast_string("Hello"))
+  end
+end

data/test/test-class.rb

@@ -0,0 +1,47 @@
+class ClassTest < Test::Unit::TestCase
+  extend Helper::Fixture
+
+  class << self
+    def startup
+      return unless self == ClassTest
+      lib_dir = File.join(__dir__, "..", "lib")
+      Dir.chdir(fixture_path("class")) do
+        system(RbConfig.ruby, "-w", "-I", lib_dir, "extconf.rb")
+        system("make")
+      end
+      require fixture_path("class", "class")
+    end
+  end
+
+  sub_test_case("no argument") do
+    def test_define_method
+      assert_equal("Hello", Greeting.new.hello)
+    end
+
+    def test_define_method_lazy
+      assert_equal("Hello", Greeting.new.hello_lazy)
+    end
+
+    def test_define_method_defined
+      assert_equal("Hello", Greeting.new.hello_defined)
+    end
+  end
+
+  sub_test_case("with arguments") do
+    def test_define_method
+      assert_equal("Hello Ruby", NamedGreeting.new.hello("Ruby"))
+    end
+
+    def test_define_method_compatible
+      assert_equal("Hello Ruby", NamedGreeting.new.hello_compatible("Ruby"))
+    end
+
+    def test_define_method_lazy
+      assert_equal("Hello Ruby", NamedGreeting.new.hello_lazy("Ruby"))
+    end
+
+    def test_define_method_defined
+      assert_equal("Hello Ruby", NamedGreeting.new.hello_defined("Ruby"))
+    end
+  end
+end

data/test/test-object.rb

@@ -0,0 +1,52 @@
+class ObjectTest < Test::Unit::TestCase
+  extend Helper::Fixture
+
+  class << self
+    def startup
+      return unless self == ObjectTest
+      lib_dir = File.join(__dir__, "..", "lib")
+      Dir.chdir(fixture_path("object")) do
+        system(RbConfig.ruby, "-w", "-I", lib_dir, "extconf.rb")
+        system("make")
+      end
+      require fixture_path("object", "object")
+    end
+  end
+
+  sub_test_case("to_bool") do
+    def test_true
+      assert_equal(true, ObjectMethods.new.to_bool_true)
+    end
+
+    def test_false
+      assert_equal(false, ObjectMethods.new.to_bool_false)
+    end
+
+    def test_nil
+      assert_equal(false, ObjectMethods.new.to_bool_nil)
+    end
+  end
+
+  def test_to_ruby
+    assert_equal("Hello", ObjectMethods.new.to_ruby("Hello"))
+  end
+
+  sub_test_case("send") do
+    def test_no_arguments
+      assert_equal("1", ObjectMethods.new.send_no_arguments(1, "to_s"))
+    end
+
+    def test_two_arguments
+      assert_equal("ell",
+                   ObjectMethods.new.send_two_arguments("hello",
+                                                        "[]",
+                                                        1,
+                                                        3))
+    end
+
+    def test_block
+      assert_equal([1, 4, 9],
+                   ObjectMethods.new.send_block([1, 2, 3], "collect"))
+    end
+  end
+end

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification
+name: extpp
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Kouhei Sutou
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-02-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: kramdown
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: packnga
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |-
+  You can write your Ruby extension easier than Ruby's C API. Because
+  Ext++'s C++ API reduces duplicated code needed for Ruby's C API.
+email:
+- kou@clear-code.com
+executables: []
+extensions:
+- ext/extpp/extconf.rb
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- Rakefile
+- doc/text/news.md
+- ext/extpp/class.cpp
+- ext/extpp/extconf.rb
+- ext/extpp/function.cpp
+- ext/extpp/object.cpp
+- include/ruby.hpp
+- include/ruby/cast.hpp
+- include/ruby/class.hpp
+- include/ruby/object.hpp
+- include/ruby/type.hpp
+- lib/extpp.rb
+- lib/extpp/compiler.rb
+- lib/extpp/version.rb
+- test/fixtures/cast/cast.cpp
+- test/fixtures/cast/extconf.rb
+- test/fixtures/class/class.cpp
+- test/fixtures/class/extconf.rb
+- test/fixtures/object/extconf.rb
+- test/fixtures/object/object.cpp
+- test/helper.rb
+- test/run-test.rb
+- test/test-cast.rb
+- test/test-class.rb
+- test/test-object.rb
+homepage: https://github.com/red-data-tools/extpp
+licenses:
+- BSD-2-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2.2
+signing_key: 
+specification_version: 4
+summary: Ext++ is a Ruby extension that provides C++ API for writing Ruby extension.
+test_files:
+- test/run-test.rb
+- test/helper.rb
+- test/test-object.rb
+- test/test-class.rb
+- test/test-cast.rb
+- test/fixtures/object/object.cpp
+- test/fixtures/object/extconf.rb
+- test/fixtures/cast/extconf.rb
+- test/fixtures/cast/cast.cpp
+- test/fixtures/class/extconf.rb
+- test/fixtures/class/class.cpp