rice 2.1.3 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ec6fa915a48070fcd2fcc2bfb2a5711bba327832fa9701e1a5cd0ea5f4470d9
-  data.tar.gz: 8ddb3bdf9ab7008efa5ed2dea6449a50cd9851af28801269e1e6cea3fb0748da
+  metadata.gz: cfc3c808fd3b1c836e1788866f93b00cf739ea459b38f3db85304adcec9c3557
+  data.tar.gz: 5b61d235b4f964750929e825bcb18ab9e91fb12b85d8d29f19f8a886e0fdd204
 SHA512:
-  metadata.gz: 7b39fdd96ae02efd1599ed1336ad4058584780939f545146302486ef5e853aae8c35a4f4768eaacced5257b5857ae9f6381fca8de8b315324fc86962c6a7bf66
-  data.tar.gz: e8f2ec83dbce8beb5df264aaeeac9a53cdaaea3d055f132460914c58ec25ab8b8b3f6a73bf4bb78561a0c684521952c4fce53da4a19a5d87f2c0908d0b774b1c
+  metadata.gz: 0c2e7b10676fece41e12fca65ada008b87ca3faa6148771cf68bf07c75c01618b49d99df4ee8d11c3fd7d0b95d18367fd26923587bedf37ae677fefd090c6c44
+  data.tar.gz: bb1340b89738f90f222cfabf6c5bf9a1496154cf8eea2e607afba793c824fcb2497c2c2b141d11e97eae9e232eff755451b477ec568ecc4d7a98200a94856aaf

data/extconf.rb

@@ -23,12 +23,9 @@ if RbConfig::CONFIG["ENABLE_SHARED"] == "no"
 Unfortunately Rice does not build against a staticly linked Ruby.
 You'll need to rebuild Ruby with --enable-shared to use this library.
 
-If you're on rvm:   rvm reinstall [version] -- --enable-shared
-If you're on rbenv: CONFIGURE_OPTS="--enable-shared" rbenv install [version]
-
-If you are using Heroku, they use a own custom configured, staticly linked Ruby
-for their stack and it unfortunately does not work with Rice. You will need to use
-a custom Ruby build pack that builds and uses a non-static version of Ruby.
+If you're on rvm:    rvm reinstall [version] -- --enable-shared
+If you're on rbenv:  CONFIGURE_OPTS="--enable-shared" rbenv install [version]
+If you're on Heroku: upgrade your stack to heroku-16 or later
 EOC
 end
 

data/rice/detail/method_data.cpp

@@ -31,6 +31,12 @@ method_data()
   return (store == Qnil) ? Qnil : rb_ivar_get(store, id);
 }
 
+// Ruby 2.7 now includes a similarly named macro that uses templates to
+// pick the right overload for the underlying function. That doesn't work
+// for our cases because we are using this method dynamically and get a
+// compilation error otherwise. This removes the macro and lets us fall
+// back to the C-API underneath again.
+#undef rb_define_method_id
 
 // Define a method and attach data to it.
 // The method looks to ruby like a normal aliased CFUNC, with a modified
@@ -75,9 +81,9 @@ define_method_with_data(
   rb_ivar_set(store, id, data);
 
   // Create the aliased method on the origin class
-  rb_define_method(
+  rb_define_method_id(
       klass,
-      rb_id2name(id),
+      id,
       cfunc,
       arity);
 

data/rice/detail/ruby_version_code.hpp

@@ -1,6 +1,6 @@
 #ifndef Rice__detail__ruby_version_code__hpp
 #define Rice__detail__ruby_version_code__hpp
 
-#define RICE__RUBY_VERSION_CODE 253
+#define RICE__RUBY_VERSION_CODE 270
 
 #endif // Rice__detail__ruby_version_code__hpp

data/rice/to_from_ruby.ipp

@@ -18,6 +18,37 @@ Rice::Object to_ruby<Rice::Object>(Rice::Object const & x)
   return x;
 }
 
+// ---------------------------------------------------------------------
+namespace Rice
+{
+  namespace detail
+  {
+    inline short num2short(VALUE x)
+    {
+      return NUM2SHORT(x);
+    }
+
+    inline VALUE short2num(short x)
+    {
+      return INT2NUM(x);
+    }
+  }
+}
+
+template<>
+inline
+short from_ruby<short>(Rice::Object x)
+{
+  return Rice::detail::num2short(x);
+}
+
+template<>
+inline
+Rice::Object to_ruby<short>(short const & x)
+{
+  return Rice::protect(Rice::detail::short2num, x);
+}
+
 // ---------------------------------------------------------------------
 namespace Rice
 {
@@ -80,6 +111,68 @@ Rice::Object to_ruby<long>(long const & x)
   return Rice::protect(Rice::detail::long2num, x);
 }
 
+// ---------------------------------------------------------------------
+namespace Rice
+{
+  namespace detail
+  {
+    inline long long num2longlong(VALUE x)
+    {
+      return NUM2LL(x);
+    }
+
+    inline VALUE longlong2num(long long x)
+    {
+      return LL2NUM(x);
+    }
+  }
+}
+
+template<>
+inline
+long long from_ruby<long long>(Rice::Object x)
+{
+  return Rice::protect(Rice::detail::num2longlong, x);
+}
+
+template<>
+inline
+Rice::Object to_ruby<long long>(long long const & x)
+{
+  return Rice::protect(Rice::detail::longlong2num, x);
+}
+
+// ---------------------------------------------------------------------
+namespace Rice
+{
+  namespace detail
+  {
+    inline unsigned short num2ushort(VALUE x)
+    {
+      return NUM2USHORT(x);
+    }
+
+    inline VALUE ushort2num(unsigned short x)
+    {
+      return UINT2NUM(x);
+    }
+  }
+}
+
+template<>
+inline
+unsigned short from_ruby<unsigned short>(Rice::Object x)
+{
+  return Rice::detail::num2ushort(x);
+}
+
+template<>
+inline
+Rice::Object to_ruby<unsigned short>(unsigned short const & x)
+{
+  return Rice::protect(Rice::detail::ushort2num, x);
+}
+
 // ---------------------------------------------------------------------
 namespace Rice
 {
@@ -142,6 +235,37 @@ Rice::Object to_ruby<unsigned long>(unsigned long const & x)
   return Rice::protect(Rice::detail::ulong2num, x);
 }
 
+// ---------------------------------------------------------------------
+namespace Rice
+{
+  namespace detail
+  {
+    inline unsigned long long num2ulonglong(VALUE x)
+    {
+      return NUM2ULL(x);
+    }
+
+    inline VALUE ulonglong2num(unsigned long long x)
+    {
+      return ULL2NUM(x);
+    }
+  }
+}
+
+template<>
+inline
+unsigned long long from_ruby<unsigned long long>(Rice::Object x)
+{
+  return Rice::protect(Rice::detail::num2ulonglong, x);
+}
+
+template<>
+inline
+Rice::Object to_ruby<unsigned long long>(unsigned long long const & x)
+{
+  return Rice::protect(Rice::detail::ulonglong2num, x);
+}
+
 // ---------------------------------------------------------------------
 template<>
 inline

data/ruby/lib/version.rb

@@ -1,3 +1,3 @@
 module Rice
-  VERSION = "2.1.3"
+  VERSION = "2.2.0"
 end

data/test/test_To_From_Ruby.cpp

@@ -27,6 +27,32 @@ TESTCASE(object_from_ruby)
   ASSERT_EQUAL(o.value(), from_ruby<Object>(o).value());
 }
 
+TESTCASE(short_to_ruby)
+{
+  ASSERT_EQUAL(INT2NUM(0), to_ruby((short)0).value());
+  ASSERT_EQUAL(INT2NUM(-1), to_ruby((short)-1).value());
+  ASSERT_EQUAL(INT2NUM(1), to_ruby((short)1).value());
+  ASSERT_EQUAL(
+      Object(INT2NUM(std::numeric_limits<short>::min())),
+      to_ruby(std::numeric_limits<short>::min()));
+  ASSERT_EQUAL(
+      Object(INT2NUM(std::numeric_limits<short>::max())),
+      to_ruby(std::numeric_limits<short>::max()));
+}
+
+TESTCASE(short_from_ruby)
+{
+  ASSERT_EQUAL(0, from_ruby<short>(INT2NUM(0)));
+  ASSERT_EQUAL(-1, from_ruby<short>(INT2NUM(-1)));
+  ASSERT_EQUAL(1, from_ruby<short>(INT2NUM(1)));
+  ASSERT_EQUAL(
+      std::numeric_limits<short>::min(),
+      from_ruby<short>(INT2NUM(std::numeric_limits<short>::min())));
+  ASSERT_EQUAL(
+      std::numeric_limits<short>::max(),
+      from_ruby<short>(INT2NUM(std::numeric_limits<short>::max())));
+}
+
 TESTCASE(int_to_ruby)
 {
   ASSERT_EQUAL(INT2NUM(0), to_ruby((int)0).value());
@@ -91,6 +117,56 @@ TESTCASE(long_from_ruby)
       from_ruby<long>(LONG2NUM(std::numeric_limits<long>::max())));
 }
 
+TESTCASE(long_long_to_ruby)
+{
+  ASSERT_EQUAL(LL2NUM(0), to_ruby((long long)0).value());
+  ASSERT_EQUAL(LL2NUM(-1), to_ruby((long long)-1).value());
+  ASSERT_EQUAL(LL2NUM(1), to_ruby((long long)1).value());
+  ASSERT_EQUAL(
+      Object(LL2NUM(std::numeric_limits<long long>::min())),
+      to_ruby(std::numeric_limits<long long>::min()));
+  ASSERT_EQUAL(
+      Object(LL2NUM(std::numeric_limits<long long>::max())),
+      to_ruby(std::numeric_limits<long long>::max()));
+}
+
+TESTCASE(long_long_from_ruby)
+{
+  ASSERT_EQUAL(0, from_ruby<long long>(LL2NUM(0)));
+  ASSERT_EQUAL(-1, from_ruby<long long>(LL2NUM(-1)));
+  ASSERT_EQUAL(1, from_ruby<long long>(LL2NUM(1)));
+  ASSERT_EQUAL(
+      std::numeric_limits<long long>::min(),
+      from_ruby<long long>(LL2NUM(std::numeric_limits<long long>::min())));
+  ASSERT_EQUAL(
+      std::numeric_limits<long long>::max(),
+      from_ruby<long long>(LL2NUM(std::numeric_limits<long long>::max())));
+}
+
+TESTCASE(unsigned_short_to_ruby)
+{
+  ASSERT_EQUAL(UINT2NUM(0), to_ruby((unsigned short)0).value());
+  ASSERT_EQUAL(UINT2NUM(1), to_ruby((unsigned short)1).value());
+  ASSERT_EQUAL(
+      Object(UINT2NUM(std::numeric_limits<unsigned short>::min())),
+      to_ruby(std::numeric_limits<unsigned short>::min()));
+  ASSERT_EQUAL(
+      Object(UINT2NUM(std::numeric_limits<unsigned short>::max())),
+      to_ruby(std::numeric_limits<unsigned short>::max()));
+}
+
+TESTCASE(unsigned_short_from_ruby)
+{
+  ASSERT_EQUAL(0u, from_ruby<unsigned short>(UINT2NUM(0)));
+  ASSERT_EQUAL(1u, from_ruby<unsigned short>(UINT2NUM(1)));
+  ASSERT_EQUAL(
+      std::numeric_limits<unsigned short>::min(),
+      from_ruby<unsigned short>(UINT2NUM(std::numeric_limits<unsigned short>::min())));
+  ASSERT_EQUAL(
+      std::numeric_limits<unsigned short>::max(),
+      from_ruby<unsigned short>(UINT2NUM(std::numeric_limits<unsigned short>::max())));
+}
+
 TESTCASE(unsigned_int_to_ruby)
 {
   ASSERT_EQUAL(UINT2NUM(0), to_ruby((unsigned int)0).value());
@@ -145,6 +221,30 @@ TESTCASE(unsigned_long_from_ruby)
       from_ruby<unsigned long>(ULONG2NUM(std::numeric_limits<unsigned long>::max())));
 }
 
+TESTCASE(unsigned_long_long_to_ruby)
+{
+  ASSERT_EQUAL(ULL2NUM(0), to_ruby((unsigned long long)0).value());
+  ASSERT_EQUAL(ULL2NUM(1), to_ruby((unsigned long long)1).value());
+  ASSERT_EQUAL(
+      Object(ULL2NUM(std::numeric_limits<unsigned long long>::min())),
+      to_ruby(std::numeric_limits<unsigned long long>::min()));
+  ASSERT_EQUAL(
+      Object(ULL2NUM(std::numeric_limits<unsigned long long>::max())),
+      to_ruby(std::numeric_limits<unsigned long long>::max()));
+}
+
+TESTCASE(unsigned_long_long_from_ruby)
+{
+  ASSERT_EQUAL(0u, from_ruby<unsigned long>(ULL2NUM(0)));
+  ASSERT_EQUAL(1u, from_ruby<unsigned long>(ULL2NUM(1)));
+  ASSERT_EQUAL(
+      std::numeric_limits<unsigned long long>::min(),
+      from_ruby<unsigned long long>(ULL2NUM(std::numeric_limits<unsigned long long>::min())));
+  ASSERT_EQUAL(
+      std::numeric_limits<unsigned long long>::max(),
+      from_ruby<unsigned long long>(ULL2NUM(std::numeric_limits<unsigned long long>::max())));
+}
+
 TESTCASE(bool_to_ruby)
 {
   ASSERT_EQUAL(Qfalse, to_ruby(false).value());

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rice
 version: !ruby/object:Gem::Version
-  version: 2.1.3
+  version: 2.2.0
 platform: ruby
 authors:
 - Paul Brannan
@@ -9,8 +9,50 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-28 00:00:00.000000000 Z
-dependencies: []
+date: 2020-01-11 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: minitest
+  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: |
   Rice is a C++ interface to Ruby's C API.  It provides a type-safe and
   exception-safe interface in order to make embedding Ruby and writing
@@ -230,15 +272,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Ruby Interface for C++ Extensions