ruby-qt6-rice 1.0.1 → 2.0.0

data/include/rice/qt6/qdbusreply.hpp

@@ -22,12 +22,9 @@
 #ifndef RICE_QDBUSREPLY_HPP
 #define RICE_QDBUSREPLY_HPP
 
-#include <rice/rice.hpp>
-#include <rice/stl.hpp>
-
 #include <QDBusReply>
 
-using namespace Rice;
+RICE4RUBYQT6_USE_NAMESPACE
 
 template <typename Value_T>
 void define_qdbusreply_under(Module module)
@@ -45,7 +42,7 @@ void define_qdbusreply_under(Module module)
         .define_constructor(Constructor<QDBusReply_T, const QDBusPendingCall &>(), Arg("pcall"))
         .define_constructor(Constructor<QDBusReply_T, const QDBusPendingReply_T &>(), Arg("reply"))
         .define_constructor(Constructor<QDBusReply_T, const QDBusReply_T &>(), Arg("other"))
-        .template define_method<const QDBusError &(QDBusReply_T::*)()>("error", &QDBusReply_T::error)
+        .template define_method<const QDBusError &(QDBusReply_T::*)() const>("error", &QDBusReply_T::error)
         .template define_method("valid?", &QDBusReply_T::isValid)
         .template define_method("value", &QDBusReply_T::value);
 };

data/include/rice/qt6/qenum.hpp

@@ -22,22 +22,38 @@
 #ifndef RICE_QENUM_HPP
 #define RICE_QENUM_HPP
 
-#include <rice/rice.hpp>
-#include <rice/stl.hpp>
-
 #include <QVariant>
 
-using namespace Rice;
+RICE4RUBYQT6_USE_NAMESPACE
+
+template<typename Enum_T>
+VALUE qenum_to_i(VALUE self)
+{
+    auto rb_return = (int)detail::From_Ruby<Enum_T>().convert(self);
+    return detail::To_Ruby<int>().convert(rb_return);
+}
+
+template<typename Enum_T>
+VALUE qenum_from_int(VALUE self, VALUE i)
+{
+    auto rb_return = static_cast<Enum_T>(detail::From_Ruby<int>().convert(i));
+    return detail::To_Ruby<Enum_T>().convert(rb_return);
+}
+
+template<typename Enum_T>
+VALUE qenum_qvariant_register_metatype(VALUE self)
+{
+    auto rb_return = qRegisterMetaType<Enum_T>();
+    return detail::To_Ruby<int>().convert(rb_return);
+}
 
 template<typename Enum_T>
 Data_Type<Enum_T> define_qenum_under(Module module, char const* name)
 {
-    Data_Type<Enum_T> qenum =
-        define_class_under<Enum_T>(module, name)
-            .template define_method("to_i", [](Enum_T *self) -> int { return (int)(*self); })
-            .define_singleton_function("_qvariant_register_metatype", []() -> int { return qRegisterMetaType<Enum_T>(); })
-            .define_singleton_function("_qvariant_from_value", [](const Enum_T &value) -> QVariant { return QVariant::fromValue(value); })
-            .define_singleton_function("_qvariant_to_value", [](const QVariant &qvariant) -> Enum_T { return qvariant.value<Enum_T>(); });
+    Data_Type<Enum_T> qenum = define_class_under<Enum_T>(module, name);
+    detail::protect(rb_define_method, qenum, "to_i", (RUBY_METHOD_FUNC)qenum_to_i<Enum_T>, 0);
+    detail::protect(rb_define_singleton_method, qenum, "from_int", (RUBY_METHOD_FUNC)qenum_from_int<Enum_T>, 1);
+    detail::protect(rb_define_singleton_method, qenum, "_qvariant_register_metatype", (RUBY_METHOD_FUNC)qenum_qvariant_register_metatype<Enum_T>, 0);
     return qenum;
 }
 

data/include/rice/qt6/qflags.hpp

@@ -22,36 +22,32 @@
 #ifndef RICE_QFLAGS_HPP
 #define RICE_QFLAGS_HPP
 
-#include <rice/rice.hpp>
-#include <rice/stl.hpp>
-
 #include <QFlags>
 
-using namespace Rice;
+RICE4RUBYQT6_USE_NAMESPACE
+
+template<typename QFlags_T>
+VALUE qflags_to_i(VALUE self)
+{
+    auto rb_return = (int)detail::From_Ruby<QFlags_T>().convert(self);
+    return detail::To_Ruby<int>().convert(rb_return);
+}
+
+template<typename QFlags_T>
+VALUE qflags_from_int(VALUE self, VALUE i)
+{
+    auto rb_return = static_cast<QFlags_T>(detail::From_Ruby<int>().convert(i));
+    return detail::To_Ruby<QFlags_T>().convert(rb_return);
+}
 
 template<typename Enum_T>
 Data_Type<QFlags<Enum_T>> define_qflags_under(Module module, char const* name)
 {
     using QFlags_T = QFlags<Enum_T>;
 
-    Data_Type<QFlags_T> qflags = define_class_under<QFlags_T>(module, name)
-        .define_constructor(Constructor<QFlags_T>())
-        .define_constructor(Constructor<QFlags_T, Enum_T>(), Arg("flags"))
-        .template define_method("to_i", [](QFlags_T *self) -> int { return (int)(*self); })
-        .template define_method("~", &QFlags_T::operator~)
-        .template define_method<QFlags_T (QFlags_T::*)(Enum_T) const noexcept>("&", &QFlags_T::operator&, Arg("mask"))
-        .template define_method<QFlags_T (QFlags_T::*)(QFlags_T) const noexcept>("&", &QFlags_T::operator&, Arg("mask"))
-        .template define_method<QFlags_T &(QFlags_T::*)(Enum_T) noexcept>("&=", &QFlags_T::operator&=, Arg("mask"))
-        .template define_method<QFlags_T &(QFlags_T::*)(QFlags_T) noexcept>("&=", &QFlags_T::operator&=, Arg("mask"))
-        .template define_method<QFlags_T (QFlags_T::*)(Enum_T) const noexcept>("^", &QFlags_T::operator^, Arg("other"))
-        .template define_method<QFlags_T (QFlags_T::*)(QFlags_T) const noexcept>("^", &QFlags_T::operator^, Arg("other"))
-        .template define_method<QFlags_T &(QFlags_T::*)(Enum_T) noexcept>("^=", &QFlags_T::operator^=, Arg("other"))
-        .template define_method<QFlags_T &(QFlags_T::*)(QFlags_T) noexcept>("^=", &QFlags_T::operator^=, Arg("other"))
-        .template define_method<QFlags_T (QFlags_T::*)(Enum_T) const noexcept>("|", &QFlags_T::operator|, Arg("other"))
-        .template define_method<QFlags_T (QFlags_T::*)(QFlags_T) const noexcept>("|", &QFlags_T::operator|, Arg("other"))
-        .template define_method<QFlags_T &(QFlags_T::*)(Enum_T) noexcept>("|=", &QFlags_T::operator|=, Arg("other"))
-        .template define_method<QFlags_T &(QFlags_T::*)(QFlags_T) noexcept>("|=", &QFlags_T::operator|=, Arg("other"))
-        .template define_singleton_function("from_int", [](int i) -> QFlags_T { return QFlags_T::fromInt(i); }, Arg("i"));
+    Data_Type<QFlags_T> qflags = define_class_under<QFlags_T>(module, name);
+    detail::protect(rb_define_method, qflags, "to_i", (RUBY_METHOD_FUNC)qflags_to_i<QFlags_T>, 0);
+    detail::protect(rb_define_singleton_method, qflags, "from_int", (RUBY_METHOD_FUNC)qflags_from_int<QFlags_T>, 1);
     return qflags;
 }
 

data/include/rice/qt6/qlist.hpp

@@ -22,12 +22,9 @@
 #ifndef RICE_QLIST_HPP
 #define RICE_QLIST_HPP
 
-#include <rice/rice.hpp>
-#include <rice/stl.hpp>
-
 #include <QList>
 
-using namespace Rice;
+RICE4RUBYQT6_USE_NAMESPACE
 
 template<typename QList_T>
 class DefineQListMethods
@@ -39,16 +36,13 @@ public:
     DefineQListMethods(Data_Type<QList_T> klass) : klass_(klass)
     {
         this->define_constructors();
-        this->define_constructable_methods();
         this->define_capacity_methods();
         this->define_access_methods();
         this->define_comparable_methods();
         this->define_insert_methods();
         this->define_remove_methods();
-        this->define_replace_methods();
         this->define_enumerable();
         this->define_to_array();
-        this->define_to_s();
     }
 
 private:
@@ -60,20 +54,10 @@ private:
         klass_.define_constructor(Constructor<QList_T, const QList_T&>(), Arg("other"));
     }
 
-    void define_constructable_methods()
-    {
-        klass_.template define_method<void (QList_T::*)(qsizetype)>("resize", &QList_T::resize, Arg("size"));
-        klass_.template define_method<void (QList_T::*)(qsizetype, Parameter_T)>("resize", &QList_T::resize, Arg("size"), Arg("value"));
-    }
-
     void define_capacity_methods()
     {
-        klass_.define_method("capacity", &QList_T::capacity);
         klass_.define_method("empty?", &QList_T::isEmpty);
-        klass_.define_method("length", &QList_T::length);
-        klass_.define_method("max_size", &QList_T::max_size);
-        klass_.define_method("reserve", &QList_T::reserve);
-        klass_.define_method("shrink_to_fit", &QList_T::shrink_to_fit);
+        klass_.define_method("length", &QList_T::size);
         klass_.define_method("size", &QList_T::size);
     }
 
@@ -109,6 +93,7 @@ private:
         klass_.define_method("count", [](QList_T *self) -> qsizetype {
             return self->size();
         });
+
         klass_.define_method("count", [](QList_T *self, Parameter_T element) -> qsizetype {
             return self->count(element);
         });
@@ -149,6 +134,21 @@ private:
             return std::nullopt;
         });
 
+        klass_.define_method("[]=", [](QList_T*self, qsizetype index, Parameter_T element) -> Parameter_T {
+            if (index < 0) {
+                index = index + self->size();
+                if (index < 0) throw std::out_of_range("index " + std::to_string(index - self->size()) + " too small for array; minimum: -" + std::to_string(self->size()));
+            } else if (index > self->size()) {
+                throw std::out_of_range("index " + std::to_string(index) + " too big");
+            }
+            if (index == self->size()) {
+                self->push_back(element);
+            } else {
+                self->replace(index, element);
+            }
+            return element;
+        });
+
         rb_define_alias(klass_, "<<", "push");
     }
 
@@ -180,30 +180,12 @@ private:
         });
     }
 
-    void define_replace_methods()
-    {
-        klass_.define_method("[]=", [](QList_T*self, qsizetype index, Parameter_T element) -> Parameter_T {
-            if (index < 0) {
-                index = index + self->size();
-                if (index < 0) throw std::out_of_range("index " + std::to_string(index - self->size()) + " too small for array; minimum: -" + std::to_string(self->size()));
-            } else if (index > self->size()) {
-                throw std::out_of_range("index " + std::to_string(index) + " too big");
-            }
-            if (index == self->size()) {
-                self->push_back(element);
-            } else {
-                self->replace(index, element);
-            }
-            return element;
-        });
-    }
-
     void define_enumerable()
     {
         klass_.include_module(rb_mEnumerable);
         klass_.define_method("each", [](QList_T *self) -> QList_T* {
             for (qsizetype i = 0; i < self->size(); i++) {
-                Rice::detail::protect(rb_yield, Rice::detail::to_ruby(self->at(i)));
+                detail::protect(rb_yield, detail::to_ruby(self->at(i)));
             }
             return self;
         });
@@ -214,10 +196,6 @@ private:
         rb_define_alias(klass_, "to_ary", "to_a");
     }
 
-    void define_to_s()
-    {
-    }
-
 private:
     Data_Type<QList_T> klass_;
 };

data/include/rice/qt6/qmap.hpp

@@ -0,0 +1,158 @@
+// This file is part of [RubyQt6](https://github.com/souk4711/ruby-qt6).
+//
+// It is licensed under the LGPLv3, included below.
+//
+// As a special exception to the GNU Lesser General Public License version 3
+// ("LGPL3"), the copyright holders of this Library give you permission to
+// convey to a third party a Combined Work that links statically or dynamically
+// to this Library without providing any Minimal Corresponding Source or
+// Minimal Application Code as set out in 4d or providing the installation
+// information set out in section 4e, provided that you comply with the other
+// provisions of LGPL3 and provided that you meet, for the Application the
+// terms and conditions of the license(s) which apply to the Application.
+//
+// Except as stated in this special exception, the provisions of LGPL3 will
+// continue to comply in full to this Library. If you modify this Library, you
+// may apply this exception to your version of this Library, but you are not
+// obliged to do so. If you do not wish to do so, delete this exception
+// statement from your version. This exception does not (and cannot) modify any
+// license terms which apply to the Application, with which you must still
+// comply.
+
+#ifndef RICE_QMAP_HPP
+#define RICE_QMAP_HPP
+
+#include <QMap>
+
+RICE4RUBYQT6_USE_NAMESPACE
+
+template<typename QMap_T>
+class DefineQMapMethods
+{
+      using Key_T = typename QMap_T::key_type;
+      using Mapped_T = typename QMap_T::mapped_type;
+
+public:
+    DefineQMapMethods(Data_Type<QMap_T> klass) : klass_(klass)
+    {
+        this->define_constructors();
+        this->define_capacity_methods();
+        this->define_access_methods();
+        this->define_comparable_methods();
+        this->define_insert_methods();
+        this->define_remove_methods();
+        this->define_enumerable();
+        this->define_to_hash();
+    }
+
+private:
+    void define_constructors()
+    {
+        klass_.define_constructor(Constructor<QMap_T>());
+        klass_.define_constructor(Constructor<QMap_T, const QMap_T&>(), Arg("other"));
+    }
+
+    void define_capacity_methods()
+    {
+        klass_.define_method("empty?", &QMap_T::isEmpty);
+        klass_.define_method("length", &QMap_T::size);
+        klass_.define_method("size", &QMap_T::size);
+    }
+
+    void define_access_methods()
+    {
+        klass_.define_method("[]", [](QMap_T *self, Key_T &key) -> std::optional<Mapped_T> {
+            auto iter = self->find(key);
+            if (iter != self->end())
+                return iter.value();
+            return std::nullopt;
+        });
+
+        klass_.define_method("keys", [](QMap_T *self) -> QList<Key_T> {
+            return self->keys();
+        });
+
+        klass_.define_method("values", [](QMap_T *self) -> QList<Mapped_T> {
+            return self->values();
+        });
+    }
+
+    void define_comparable_methods()
+    {
+        klass_.define_method("has_key?", [](QMap_T *self, Key_T &key) -> bool {
+            return self->contains(key);
+        });
+
+        klass_.define_method("has_value?", [](QMap_T *self, Mapped_T &value) -> bool {
+            for (auto i = self->cbegin(), end = self->cend(); i != end; ++i)
+                if (i.value() == value)
+                    return true;
+            return false;
+        });
+
+        rb_define_alias(klass_, "key?", "has_key?");
+        rb_define_alias(klass_, "value?", "has_value?");
+    }
+
+    void define_insert_methods()
+    {
+        klass_.define_method("insert", [](QMap_T *self, Key_T &key, Mapped_T &value) -> Mapped_T {
+            self->insert(key, value);
+            return value;
+        });
+
+        rb_define_alias(klass_, "[]=", "insert");
+    }
+
+    void define_remove_methods()
+    {
+        klass_.define_method("clear", [](QMap_T *self) -> QMap_T* {
+            self->clear();
+            return self;
+        });
+
+        klass_.define_method("delete", [](QMap_T *self, Key_T &key) -> std::optional<Mapped_T> {
+            auto iter = self->find(key);
+            if (iter != self->cend()) {
+                Mapped_T result = iter.value();
+                self->erase(iter);
+                return result;
+            }
+            return std::nullopt;
+        });
+    }
+
+    void define_enumerable()
+    {
+        klass_.include_module(rb_mEnumerable);
+        klass_.define_method("each", [](QMap_T *self) -> QMap_T* {
+            for (auto i = self->cbegin(), end = self->cend(); i != end; ++i) {
+                detail::protect(rb_yield_values, 2, detail::to_ruby(i.key()), detail::to_ruby(i.value()));
+            }
+            return self;
+        });
+    }
+
+    void define_to_hash()
+    {
+        rb_define_alias(klass_, "to_hash", "to_h");
+    }
+
+private:
+    Data_Type<QMap_T> klass_;
+};
+
+template <typename Key_T, typename Mapped_T>
+void define_qmap_under(Module module)
+{
+    using QMap_T = QMap<Key_T, Mapped_T>;
+
+    detail::TypeMapper<QMap_T> typeMapper;
+    std::string klassName = typeMapper.rubyName();
+    Identifier id(klassName);
+
+    Data_Type<QMap_T> qmap = define_class_under<QMap_T>(module, id);
+    DefineQMapMethods<QMap_T> qmap_(qmap);
+}
+
+#endif

data/include/rice/qt6.hpp

@@ -0,0 +1,39 @@
+// This file is part of [RubyQt6](https://github.com/souk4711/ruby-qt6).
+//
+// It is licensed under the LGPLv3, included below.
+//
+// As a special exception to the GNU Lesser General Public License version 3
+// ("LGPL3"), the copyright holders of this Library give you permission to
+// convey to a third party a Combined Work that links statically or dynamically
+// to this Library without providing any Minimal Corresponding Source or
+// Minimal Application Code as set out in 4d or providing the installation
+// information set out in section 4e, provided that you comply with the other
+// provisions of LGPL3 and provided that you meet, for the Application the
+// terms and conditions of the license(s) which apply to the Application.
+//
+// Except as stated in this special exception, the provisions of LGPL3 will
+// continue to comply in full to this Library. If you modify this Library, you
+// may apply this exception to your version of this Library, but you are not
+// obliged to do so. If you do not wish to do so, delete this exception
+// statement from your version. This exception does not (and cannot) modify any
+// license terms which apply to the Application, with which you must still
+// comply.
+
+#ifndef RICE_QT6_HPP
+#define RICE_QT6_HPP
+
+// include rice stuffs
+#include <rice/core/rice.hpp>
+#include <rice/core/stl.hpp>
+
+// ruby/win32.h has a few defines that conflict with libQt6
+#ifdef _WIN32
+#  undef access
+#  undef stat
+#  undef truncate
+#endif
+
+// macros
+#define RICE4RUBYQT6_USE_NAMESPACE using namespace ::Rice4RubyQt6;
+
+#endif

data/lib/mkmf-rice.rb

@@ -61,8 +61,8 @@ end
 # to make this easy
 path = File.expand_path(File.join(__dir__, '../include'))
 
-unless find_header('rice/rice.hpp', path)
-  raise("Could not find rice/rice.hpp header")
+unless find_header('rice/core/rice.hpp', path)
+  raise("Could not find rice/core/rice.hpp header")
 end
 
 if !IS_DARWIN && !IS_MSWIN && !have_library('stdc++fs')

data/lib/mkmf-rubyqt6.rb

@@ -5,24 +5,57 @@ require_relative "mkmf-rice"
 def qmake
   return @qmake if @qmake
 
+  r = (ENV["QMAKE"] || "").strip
+  return @qmake = r if r != ""
+
   ["qmake6", "qmake"].each do |qmake|
     `#{qmake} -v`
     return @qmake = qmake if $?.success?
   end
-  raise "Could not find qmake"
+
+  raise "Could not find qmake, " \
+    "please add qmake to your PATH environment variable"
 end
 
-def qt_install_headers
-  return @qt_install_headers if @qt_install_headers
+qmake_persistent_props = {}
+%w[QT_INSTALL_HEADERS QT_INSTALL_LIBS].each do |name|
+  define_method(name.downcase) do
+    return qmake_persistent_props[name] if qmake_persistent_props[name]
 
-  r = ENV["QT_INSTALL_HEADERS"] || ""
-  return @qt_install_headers = r unless r == ""
+    r = (ENV[name] || "").strip
+    return qmake_persistent_props[name] = r if r != ""
 
-  r = `#{qmake} -query QT_INSTALL_HEADERS`.strip
-  return @qt_install_headers = r unless r == ""
+    r = `#{qmake} -query #{name}`.strip
+    return qmake_persistent_props[name] = r if r != ""
 
-  raise "Could not determine QT_INSTALL_HEADERS folder"
+    raise "Could not determine #{name} folder"
+  end
 end
 
-RUBYQT6_CXX_FLAGS = ENV["RUBYQT6_CXX_FLAGS"] || "-Os -fno-fast-math"
-append_cppflags(RUBYQT6_CXX_FLAGS) unless RUBYQT6_CXX_FLAGS.strip == ""
+def rubyqt6_extconf(mod, depends:)
+  # Add custom cxxflags
+  r = (ENV["RUBYQT6_CXXFLAGS"] || "").strip
+  append_cppflags(r) if r != ""
+
+  # Add rubyqt6 cxxflag
+  r = "RUBYQT6_BUILD_#{mod.upcase}_LIB"
+  append_cppflags("-D#{r}")
+
+  # Add qt6 included directories
+  append_cppflags("-I#{qt_install_headers}")
+  (Array(depends) + Array(mod)).each do |name|
+    includedir = File.join(qt_install_headers, name)
+    append_cppflags("-I#{includedir}")
+  end
+
+  # Add qt6 libraries
+  (Array(depends) + Array(mod)).each do |name|
+    library = name.sub("Qt", "Qt6")
+    message = "Could not find lib#{library}, please install qt6 package"
+    raise message unless find_library(library, nil, qt_install_libs)
+  end
+
+  # Create Makefile
+  name = mod.downcase
+  create_makefile("qt6/#{name}/#{name}")
+end

data/lib/qt6/rice/version.rb

@@ -2,6 +2,6 @@
 
 module RubyQt6
   module Rice
-    RICE_RUBYGEM_VERSION = "1.0.1"
+    RICE_RUBYGEM_VERSION = "2.0.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-qt6-rice
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.0
 platform: ruby
 authors:
 - John Doe
@@ -27,21 +27,22 @@ files:
 - include/bando/qobject/qdbusabstractinterface.hpp
 - include/bando/qobject/qitemdelegate.hpp
 - include/bando/qobject/qlayout.hpp
+- include/bando/qobject/qwebenginepage.hpp
 - include/bando/qwidget.hpp
 - include/bando/qwidget/qspinbox.hpp
+- include/rice/core/api.hpp
+- include/rice/core/rice.hpp
+- include/rice/core/stl.hpp
+- include/rice/qt6.hpp
 - include/rice/qt6/qdbusreply.hpp
 - include/rice/qt6/qenum.hpp
 - include/rice/qt6/qflags.hpp
 - include/rice/qt6/qlist.hpp
-- include/rice/rice.hpp
-- include/rice/stl.hpp
+- include/rice/qt6/qmap.hpp
 - lib/mkmf-rice.rb
 - lib/mkmf-rubyqt6.rb
 - lib/qt6/rice.rb
 - lib/qt6/rice/version.rb
-- lib/qt6/rspec.rb
-- lib/qt6/rspec/bando_file_parser.rb
-- lib/qt6/rspec/qlass_file_parser.rb
 homepage: https://github.com/souk4711/ruby-qt6
 licenses: []
 metadata:
@@ -55,7 +56,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="