extpp 0.0.9 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ad1ded05bdc3f935efd716bf7efca2248ff163e32ead6ad7fd2207d9c49e883
-  data.tar.gz: b8439db5e84748907e4f4e744ee3916e96ab70b1284a6f63a376678a6d3669fb
+  metadata.gz: 497043ee18ee638fb729cb13bb033cb95a794296117bf29f0529fb4627659a45
+  data.tar.gz: 88aef4c077dd07d3706b15c777d4d67b9c74bc3288dc40076c2b4aa713c838ef
 SHA512:
-  metadata.gz: d55f0224494159be0b951787bcf5e28990f7cbd2b5a17aabdce821dcc390ca9309c8f4eb7d04db755c1bd3defb6c45807592cfb672a41af45c060de7c497fccd
-  data.tar.gz: 3f9fb2d6a8e80e7087e5f45b8713fad57166fcfbd29e43c03c16bea3db62865def8413ea815022f02f7e08d896eebf40f5b9b6add4cb4d4f55ce334d3a8a54f2
+  metadata.gz: 01b1d893b498ad1863f6025e9bb3fc9cff7849e96471d2c9d094352942b5669ba87fe9cc532489788b3f1e019938a10682be468f679325b066354ba9822fded2
+  data.tar.gz: 87b78b0f20601ecb010008656fa3ab3bd1a5d8d0623a355e728f9c6097949969cc6785d534ece191ff1f23717ff70f544bf618e227c57fcc7b8b448228ddb32c

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (C) 2017 Kouhei Sutou. All rights reserved.
+Copyright (C) 2017-2021 Sutou Kouhei. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions

data/README.md

@@ -90,12 +90,12 @@ Build this extension:
 Now, you can use this extension:
 
 ```console
-% ruby -r extpp/setup -r ./hello -e 'p Hello.new("me").greet'
+% ruby -r ./hello -e 'p Hello.new("me").greet'
 "Hello me"
 ```
 
 ## License
 
-Copyright (C) 2017-2019 Kouhei Sutou
+Copyright (C) 2017-2021 Sutou Kouhei
 
 The 2-Clause BSD License. See [LICENSE.txt](LICENSE.txt) for details.

data/Rakefile

@@ -13,36 +13,9 @@ end
 
 helper.install
 
-def run_extconf(*arguments)
-  cd("ext/extpp") do
-    ruby("extconf.rb", *arguments)
-  end
-end
-
-desc "Configure"
-task :configure do
-  run_extconf
-end
-
-namespace :configure do
-  desc "Configure for debug"
-  task :debug do
-    run_extconf("--enable-debug-build")
-  end
-end
-
-task :clean do
-  makefile = "ext/extpp/Makefile"
-  if File.exists?(makefile)
-    cd(File.dirname(makefile)) do
-      sh("make", "clean")
-    end
-  end
-end
-
 desc "Run tests"
 task :test do
   ruby("test/run-test.rb")
 end
 
-task default: ["configure:debug", :test]
+task default: :test

data/doc/text/news.md

@@ -1,5 +1,17 @@
 # News
 
+## 0.1.1 - 2022-11-02
+
+### Improvements
+
+  * Removed needless a workaround for old Ruby with C++17.
+
+## 0.1.0 - 2021-10-03
+
+### Improvements
+
+  * Implemented as header only library.
+
 ## 0.0.9 - 2020-11-03
 
 ### Improvements

data/include/ruby/class.hpp

@@ -1,26 +1,203 @@
 #pragma once
 
+#include <ruby/function.hpp>
 #include <ruby/object.hpp>
 
+#include <string>
+#include <unordered_map>
+#include <vector>
+
 namespace rb {
-  class RB_EXTPP_EXPORT Class: public Object {
+  using MethodTable = std::unordered_map<ID, Function *>;
+
+  struct MethodDefinition {
+    MethodDefinition(std::string name_, Function *function_) :
+      name(name_),
+      function(function_) {
+    }
+
+    std::string name;
+    Function *function;
+  };
+  using MethodDefinitions = std::vector<MethodDefinition>;
+
+  namespace {
+    inline MethodTable *method_table_from_ruby(VALUE rb_method_table) {
+      return reinterpret_cast<MethodTable *>(NUM2ULL(rb_method_table));
+    }
+
+    inline VALUE method_table_to_ruby(MethodTable *method_table) {
+      return ULL2NUM(reinterpret_cast<uintptr_t>(method_table));
+    }
+
+    inline MethodDefinitions *
+    method_definitions_from_ruby(VALUE rb_definitions) {
+      return reinterpret_cast<MethodDefinitions *>(NUM2ULL(rb_definitions));
+    }
+
+    inline VALUE method_definitions_to_ruby(MethodDefinitions *definitions) {
+      return ULL2NUM(reinterpret_cast<uintptr_t>(definitions));
+    }
+
+    inline VALUE call_func(int argc, VALUE *argv, VALUE self) {
+      auto rb_method_table =
+        rb_ivar_get(rb_obj_class(self), rb_intern("__method_table__"));
+      auto method_table = method_table_from_ruby(rb_method_table);
+      auto method_name_symbol = rb_funcall(self, rb_intern("__method__"), 0);
+      auto function = (*method_table)[rb_sym2id(method_name_symbol)];
+      return function->call(self, argc, argv);
+    }
+
+    inline bool flush_method_definitions(VALUE klass) {
+      ID id_method_definitions = rb_intern("__method_definitions__");
+      auto rb_definitions = rb_ivar_get(klass, id_method_definitions);
+      if (NIL_P(rb_definitions)) {
+        return false;
+      }
+
+      auto definitions = method_definitions_from_ruby(rb_definitions);
+      auto rb_method_table = rb_ivar_get(klass, rb_intern("__method_table__"));
+      auto method_table = method_table_from_ruby(rb_method_table);
+      for (const auto &definition : *definitions) {
+        ID name_id = rb_intern(definition.name.c_str());
+        (*method_table)[name_id] = definition.function;
+        rb_define_method(klass,
+                         definition.name.c_str(),
+                         reinterpret_cast<rb::RawMethod>(call_func),
+                         -1);
+      }
+      rb_ivar_set(klass, id_method_definitions, Qnil);
+      return true;
+    }
+
+    inline VALUE method_missing(int argc, VALUE *argv, VALUE self) {
+      auto klass = rb_obj_class(self);
+
+      if (flush_method_definitions(klass)) {
+        auto rb_method_table = rb_ivar_get(klass, rb_intern("__method_table__"));
+        auto method_table = method_table_from_ruby(rb_method_table);
+
+        VALUE rb_name_symbol;
+        VALUE rb_args;
+        rb_scan_args(argc, argv, "1*", &rb_name_symbol, &rb_args);
+        auto function = (*method_table)[rb_sym2id(rb_name_symbol)];
+        if (function) {
+          return function->call(self,
+                                static_cast<int>(RARRAY_LEN(rb_args)),
+                                RARRAY_PTR(rb_args));
+        }
+      }
+
+      return rb_call_super(argc, argv);
+    }
+
+    inline VALUE respond_to_missing_p(VALUE self,
+                                      VALUE rb_name_symbol,
+                                      VALUE rb_include_private) {
+      auto klass = rb_obj_class(self);
+
+      if (flush_method_definitions(klass)) {
+        auto rb_method_table = rb_ivar_get(klass, rb_intern("__method_table__"));
+        auto method_table = method_table_from_ruby(rb_method_table);
+
+        auto function = (*method_table)[rb_sym2id(rb_name_symbol)];
+        if (function) {
+          return Qtrue;
+        }
+      }
+
+      VALUE rb_args[] = {rb_name_symbol, rb_include_private};
+      return rb_call_super(2, rb_args);
+    }
+  }
+
+  class Class: public Object {
   public:
-    Class(const char *name);
-    Class(const char *name, VALUE parent);
-    Class(VALUE klass);
-    ~Class();
+    Class(const char *name) :
+      Class(RTEST(rb_funcall(rb_cObject,
+                              rb_intern("const_defined?"),
+                              1,
+                              rb_str_new_static(name, strlen(name)))) ?
+             rb_funcall(rb_cObject,
+                        rb_intern("const_get"),
+                        1,
+                        rb_str_new_static(name, strlen(name))) :
+            rb_define_class(name, rb_cObject)) {
+    }
+
+    Class(const char *name, VALUE parent) :
+      Class(rb_define_class(name, parent)) {
+    }
+
+    Class(VALUE klass) :
+      Object(klass),
+      class_(klass),
+      method_table_(new MethodTable()),
+      lazy_define_method_(false),
+      method_definitions_(nullptr) {
+      rb_iv_set(class_,
+                "__method_table__",
+                method_table_to_ruby(method_table_));
+      rb_iv_set(class_, "__method_definitions__", Qnil);
+    }
+
+    inline Class &define_method(const char *name,
+                                MethodWithoutArguments body) {
+      auto function = new FunctionWithoutArgument(body);
+      return define_method(name, function);
+    }
+
+    inline Class &define_method(const char *name,
+                                MethodWithArguments body) {
+      auto function = new FunctionWithArguments(body);
+      return define_method(name, function);
+    }
+
+    inline Class &define_method(const char *name,
+                                MethodWithArgumentsCompatible body) {
+      auto function = new FunctionWithArgumentsCompatible(body);
+      return define_method(name, function);
+    }
+
+    inline Class &define_method(const char *name, Function *function) {
+      if (lazy_define_method_) {
+        method_definitions_->emplace_back(name, function);
+      } else {
+        ID name_id = rb_intern(name);
+        (*method_table_)[name_id] = function;
+        rb_define_method(class_,
+                         name,
+                         reinterpret_cast<RawMethod>(call_func),
+                         -1);
+      }
+      return (Class &)*this;
+    }
 
-    Class &define_method(const char *name,
-                         MethodWithoutArguments body);
-    Class &define_method(const char *name,
-                         MethodWithArguments body);
-    Class &define_method(const char *name,
-                         MethodWithArgumentsCompatible body);
+    inline Class &enable_lazy_define_method() {
+      if (lazy_define_method_) {
+        return (Class &)*this;
+      }
 
-    Class &enable_lazy_define_method();
+      lazy_define_method_ = true;
+      method_definitions_ = new MethodDefinitions();
+      rb_iv_set(class_,
+                "__method_definitions__",
+                method_definitions_to_ruby(method_definitions_));
+      rb_define_method(class_,
+                       "method_missing",
+                       reinterpret_cast<RawMethod>(method_missing),
+                       -1);
+      rb_define_method(class_,
+                       "respond_to_missing?",
+                       reinterpret_cast<RawMethod>(respond_to_missing_p),
+                       -1);
+      return (Class &)*this;
+    }
 
   private:
-    class ClassImpl;
-    ClassImpl *impl_;
+    VALUE class_;
+    MethodTable *method_table_;
+    bool lazy_define_method_;
+    MethodDefinitions *method_definitions_;
   };
 }

data/{ext/extpp → include/ruby}/function.hpp

@@ -13,9 +13,13 @@ namespace rb {
 
   class FunctionWithoutArgument : public Function {
   public:
-    FunctionWithoutArgument(const MethodWithoutArguments &function);
+    FunctionWithoutArgument(const MethodWithoutArguments &function) :
+      function_(function) {
+    }
 
-    VALUE call(VALUE self, int argc, VALUE *argv) override;
+    inline VALUE call(VALUE self, int argc, VALUE *argv) override {
+      return function_(self);
+    }
 
   private:
     MethodWithoutArguments function_;
@@ -23,9 +27,13 @@ namespace rb {
 
   class FunctionWithArguments : public Function {
   public:
-    FunctionWithArguments(const MethodWithArguments &function);
+    FunctionWithArguments(const MethodWithArguments &function) :
+      function_(function) {
+    }
 
-    VALUE call(VALUE self, int argc, VALUE *argv) override;
+    inline VALUE call(VALUE self, int argc, VALUE *argv) override {
+      return function_(self, argc, argv);
+    }
 
   private:
     MethodWithArguments function_;
@@ -33,9 +41,14 @@ namespace rb {
 
   class FunctionWithArgumentsCompatible : public Function {
   public:
-    FunctionWithArgumentsCompatible(const MethodWithArgumentsCompatible &function);
-
-    VALUE call(VALUE self, int argc, VALUE *argv) override;
+    FunctionWithArgumentsCompatible(
+      const MethodWithArgumentsCompatible &function) :
+      function_(function) {
+    }
+
+    inline VALUE call(VALUE self, int argc, VALUE *argv) override {
+      return function_(argc, argv, self);
+    }
 
   private:
     MethodWithArgumentsCompatible function_;

data/include/ruby/object.hpp

@@ -5,7 +5,7 @@
 #include <initializer_list>
 
 namespace rb {
-  class RB_EXTPP_EXPORT Object {
+  class Object {
   public:
     explicit Object(VALUE rb_object=Qnil) :
       rb_object_(rb_object),
@@ -56,7 +56,10 @@ namespace rb {
       rb_gc_register_address(&rb_object_);
     }
 
-    Object send(ID name_id);
+    inline Object send(ID name_id) {
+      VALUE rb_result = rb_funcall(rb_object_, name_id, 0);
+      return Object(rb_result);
+    }
 
     inline Object send(const char *name) {
       return send(rb_intern(name));
@@ -66,7 +69,19 @@ namespace rb {
       return send(rb_intern_str(name));
     }
 
-    Object send(ID name_id, std::initializer_list<VALUE> args);
+    inline Object send(ID name_id, std::initializer_list<VALUE> args) {
+      auto n = args.size();
+      VALUE rb_args[n];
+      int i = 0;
+      for (auto arg : args) {
+        rb_args[i++] = arg;
+      }
+      VALUE rb_result = rb_funcallv(rb_object_,
+                                    name_id,
+                                    static_cast<int>(n),
+                                    rb_args);
+      return Object(rb_result);
+    }
 
     inline Object send(const char *name, std::initializer_list<VALUE> args) {
       return send(rb_intern(name), args);
@@ -76,9 +91,33 @@ namespace rb {
       return send(rb_intern_str(name), args);
     }
 
-    Object send(ID name_id,
-                std::initializer_list<VALUE> args,
-                MethodWithoutArguments block);
+    inline Object send(ID name_id,
+                       std::initializer_list<VALUE> args,
+                       MethodWithoutArguments block) {
+      auto n = args.size();
+      VALUE rb_args[n];
+      int i = 0;
+      for (auto arg : args) {
+        rb_args[i++] = arg;
+      }
+      auto call_block = [](RB_BLOCK_CALL_FUNC_ARGLIST(rb_data, rb_block)) {
+        auto block = reinterpret_cast<rb::MethodWithoutArguments>(rb_block);
+        return block(rb_data);
+      };
+#ifdef RUBY_BACKWARD_CXXANYARGS_HPP
+#  define CAST_CALLER(caller) caller
+#else
+#  define CAST_CALLER(caller) reinterpret_cast<RawMethod>(+caller)
+#endif
+      auto rb_result = rb_block_call(rb_object_,
+                                     name_id,
+                                     static_cast<int>(n),
+                                     rb_args,
+                                     CAST_CALLER(call_block),
+                                     reinterpret_cast<VALUE>(block));
+#undef CAST_CALLER
+      return Object(rb_result);
+    }
 
     inline Object send(const char *name,
                        std::initializer_list<VALUE> args,

data/include/ruby/protect.hpp

@@ -3,7 +3,7 @@
 #include <ruby/type.hpp>
 
 namespace rb {
-  class RB_EXTPP_EXPORT State {
+  class State {
   public:
     explicit State(int state) :
       state_(state) {
@@ -17,7 +17,14 @@ namespace rb {
     int state_;
   };
 
-  RB_EXTPP_EXPORT VALUE protect(RawCallback callback, VALUE callback_data);
+  inline VALUE protect(RawCallback callback, VALUE callback_data) {
+    int state = 0;
+    auto result = rb_protect(callback, callback_data, &state);
+    if (state != 0) {
+      throw State(state);
+    }
+    return result;
+  }
 
   template <typename NoArgumentCallback>
   VALUE protect(const NoArgumentCallback& callback) {

data/include/ruby.hpp

@@ -5,16 +5,6 @@
 #define RB_BEGIN_DECLS extern "C" {
 #define RB_END_DECLS }
 
-#ifdef _WIN32
-#  ifdef RB_EXTPP_COMPILATION
-#    define RB_EXTPP_EXPORT __declspec(dllexport)
-#  else
-#    define RB_EXTPP_EXPORT __declspec(dllimport)
-#  endif
-#else
-#  define RB_EXTPP_EXPORT __attribute__((visibility("default")))
-#endif
-
 #include <ruby/cast.hpp>
 #include <ruby/class.hpp>
 #include <ruby/object.hpp>

data/lib/extpp/compiler.rb

@@ -92,12 +92,6 @@ module ExtPP
         end
 
         if std
-          if std == "gnu++17"
-            # ruby/intern.h doesn't adapt to C++17. Because it uses
-            # "register" for "rb_mem_clear(register VALUE *mem,
-            # register long size)".  C++17 removes "register" keyword.
-            std = "gnu++14"
-          end
           @cxx_flags += " -std=#{std}"
           @cxx_flags += " #{cxx_flags}" if cxx_flags
           [version, " (#{std})"]

data/lib/extpp/setup.rb

@@ -1,4 +0,0 @@
-if Object.const_defined?(:RubyInstaller)
-  ext_dir = File.expand_path(File.join(__dir__, "..", "..", "ext", "extpp"))
-  RubyInstaller::Runtime.add_dll_directory(ext_dir)
-end

data/lib/extpp/version.rb

@@ -1,3 +1,3 @@
 module ExtPP
-  VERSION = "0.0.9"
+  VERSION = "0.1.1"
 end

data/lib/extpp.rb

@@ -1,5 +1,4 @@
 require "extpp/compiler"
-require "extpp/platform"
 
 compiler = ExtPP::Compiler.new(RbConfig.expand($CXXFLAGS))
 compiler.check
@@ -26,14 +25,3 @@ $(OBJS): $(extpp_headers)
   end
 end
 extend(header_files_dependency_injector)
-
-platform = ExtPP::Platform.new
-
-[
-  File.join(__dir__, "..", "ext", "extpp"),
-  __dir__,
-].each do |candidate_dir|
-  so_name = "libruby-extpp.#{platform.dynamic_library_extension}"
-  lib_path = File.expand_path(File.join(candidate_dir, so_name))
-  $LIBS += " #{lib_path.quote}" if File.exist?(lib_path)
-end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: extpp
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.1.1
 platform: ruby
 authors:
 - Kouhei Sutou
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-11-02 00:00:00.000000000 Z
+date: 2022-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,69 +58,32 @@ description: |-
 email:
 - kou@clear-code.com
 executables: []
-extensions:
-- ext/extpp/extconf.rb
+extensions: []
 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/function.hpp
-- ext/extpp/object.cpp
-- ext/extpp/protect.cpp
 - include/ruby.hpp
 - include/ruby/cast.hpp
 - include/ruby/class.hpp
+- include/ruby/function.hpp
 - include/ruby/object.hpp
 - include/ruby/protect.hpp
 - include/ruby/type.hpp
 - lib/extpp.rb
 - lib/extpp/compiler.rb
-- lib/extpp/platform.rb
 - lib/extpp/setup.rb
 - lib/extpp/version.rb
 - sample/hello/Rakefile
 - sample/hello/extconf.rb
 - sample/hello/hello.cpp
-- test/fixtures/cast/Makefile
-- test/fixtures/cast/cast.cpp
-- test/fixtures/cast/cast.o
-- test/fixtures/cast/cast.so
-- test/fixtures/cast/extconf.rb
-- test/fixtures/cast/mkmf.log
-- test/fixtures/class/Makefile
-- test/fixtures/class/class.cpp
-- test/fixtures/class/class.o
-- test/fixtures/class/class.so
-- test/fixtures/class/extconf.rb
-- test/fixtures/class/mkmf.log
-- test/fixtures/object/Makefile
-- test/fixtures/object/extconf.rb
-- test/fixtures/object/mkmf.log
-- test/fixtures/object/object.cpp
-- test/fixtures/object/object.o
-- test/fixtures/object/object.so
-- test/fixtures/protect/Makefile
-- test/fixtures/protect/extconf.rb
-- test/fixtures/protect/mkmf.log
-- test/fixtures/protect/protect.cpp
-- test/fixtures/protect/protect.o
-- test/fixtures/protect/protect.so
-- test/helper.rb
-- test/run-test.rb
-- test/test-cast.rb
-- test/test-class.rb
-- test/test-object.rb
-- test/test-protect.rb
 homepage: https://github.com/red-data-tools/extpp
 licenses:
 - BSD-2-Clause
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -135,38 +98,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.0.rc.2
-signing_key: 
+rubygems_version: 3.4.0.dev
+signing_key:
 specification_version: 4
 summary: Ext++ is a Ruby extension that provides C++ API for writing Ruby extension.
-test_files:
-- test/fixtures/cast/Makefile
-- test/fixtures/cast/cast.cpp
-- test/fixtures/cast/cast.o
-- test/fixtures/cast/cast.so
-- test/fixtures/cast/extconf.rb
-- test/fixtures/cast/mkmf.log
-- test/fixtures/class/Makefile
-- test/fixtures/class/class.cpp
-- test/fixtures/class/class.o
-- test/fixtures/class/class.so
-- test/fixtures/class/extconf.rb
-- test/fixtures/class/mkmf.log
-- test/fixtures/object/Makefile
-- test/fixtures/object/extconf.rb
-- test/fixtures/object/mkmf.log
-- test/fixtures/object/object.cpp
-- test/fixtures/object/object.o
-- test/fixtures/object/object.so
-- test/fixtures/protect/Makefile
-- test/fixtures/protect/extconf.rb
-- test/fixtures/protect/mkmf.log
-- test/fixtures/protect/protect.cpp
-- test/fixtures/protect/protect.o
-- test/fixtures/protect/protect.so
-- test/helper.rb
-- test/run-test.rb
-- test/test-cast.rb
-- test/test-class.rb
-- test/test-object.rb
-- test/test-protect.rb
+test_files: []