RubyGems - ruby-qt6-qtnetwork - Versions diffs - 2.0.0 → 2.0.1 - Mend

ruby-qt6-qtnetwork 2.0.0 → 2.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

checksums.yaml +4 -4
data/ext/qt6/qtnetwork/qnetworkaccessmanager-rb.cpp +88 -0
data/ext/qt6/qtnetwork/qnetworkaccessmanager-rb.hpp +5 -0
data/ext/qt6/qtnetwork/qnetworkreply-rb.cpp +95 -0
data/ext/qt6/qtnetwork/qnetworkreply-rb.hpp +5 -0
data/ext/qt6/qtnetwork/qnetworkrequest-rb.cpp +142 -0
data/ext/qt6/qtnetwork/qnetworkrequest-rb.hpp +5 -0
data/ext/qt6/qtnetwork/qtnetwork-rb.cpp +8 -0
data/lib/qt6/qtnetwork/qnetworkaccessmanager.rb +31 -0
data/lib/qt6/qtnetwork/qnetworkreply.rb +37 -0
data/lib/qt6/qtnetwork/qnetworkrequest.rb +41 -0
data/lib/qt6/qtnetwork/version.rb +1 -1
data/lib/qt6/qtnetwork.rb +4 -0
metadata +10 -1

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a7421ca4bf7a73d993539afbfb12f1ee951b10fdeb4319600d7c3d1b0aba99fa
-  data.tar.gz: cc0048ead4510163e2d767bc7c7465adc9c230bcab1a0654aa063557de7bf307
+  metadata.gz: 5762ab5fdc24d1f54c3adaa3ef0a87d143ee8e9ad1f4975c8f51c0eb96840c14
+  data.tar.gz: 71f751cde61c97abad8fc2fb95f200d12248ea458175a9e1147841fe9667f2e8
 SHA512:
-  metadata.gz: d608bd39b3ac5d7b0f35589cbc2eef40bacdc0bb1500e1713c9968c2c4aa6980d216fd8d2595db1b58c1fe680b78e44e4c77621ea4761870119afb1f8f5ba334
-  data.tar.gz: dc7f194923478f97856d6d917331d8e19cf12b4ae87f1d6956e0aca1a9171142f7bb1f767acd21d504132f8e5e9f532e6425d8e5f2fa51c880fc10390b776f34
+  metadata.gz: 22d7f195db3a8d04fcabb8df5da5dea7cc70c95bda99c2977efe45271af157f7e98932131f7e4150b7699c55ab19a782125cb75f99ba1ce6c21b32c1aecf60c7
+  data.tar.gz: 69259a1f38f2018eac6bdc8b6f608b37682470adfc43a1088b6f9f69e9794edf5553bd5b06d34263ea5f991f38ab662321928eb4e72c9c020bb731fd4670a7c5

data/ext/qt6/qtnetwork/qnetworkaccessmanager-rb.cpp ADDED Viewed

@@ -0,0 +1,88 @@
+#include "qnetworkaccessmanager-rb.hpp"
+#include <qnetworkaccessmanager.h>
+#include <rice/qt6/qenum.hpp>
+#include <QAbstractNetworkCache>
+#include <QHstsPolicy>
+#include <QHttpMultiPart>
+#include <QNetworkCookieJar>
+#include <QNetworkProxy>
+#include <QNetworkProxyFactory>
+#include <QNetworkReply>
+RICE4RUBYQT6_USE_NAMESPACE
+Class rb_cQNetworkAccessManager;
+void Init_qnetworkaccessmanager(Module rb_mQt6QtNetwork)
+{
+    rb_cQNetworkAccessManager =
+        // RubyQt6::QtNetwork::QNetworkAccessManager
+        define_class_under<QNetworkAccessManager, QObject>(rb_mQt6QtNetwork, "QNetworkAccessManager")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QNetworkAccessManager::staticMetaObject; })
+            // Constructor
+            .define_constructor(Constructor<QNetworkAccessManager, QObject *>(), Arg("parent"))
+            // Public Functions
+            .define_method("add_strict_transport_security_hosts", &QNetworkAccessManager::addStrictTransportSecurityHosts, Arg("known_hosts"))
+            .define_method("auto_delete_replies", &QNetworkAccessManager::autoDeleteReplies)
+            .define_method("cache", &QNetworkAccessManager::cache)
+            .define_method("clear_access_cache", &QNetworkAccessManager::clearAccessCache)
+            .define_method("clear_connection_cache", &QNetworkAccessManager::clearConnectionCache)
+            .define_method("connect_to_host", &QNetworkAccessManager::connectToHost, Arg("host_name"), Arg("port") = static_cast<quint16>(80))
+            .define_method<void (QNetworkAccessManager::*)(const QString &, quint16, const QSslConfiguration &)>("connect_to_host_encrypted", &QNetworkAccessManager::connectToHostEncrypted, Arg("host_name"), Arg("port") = static_cast<quint16>(443), Arg("ssl_configuration"))
+            .define_method<void (QNetworkAccessManager::*)(const QString &, quint16, const QSslConfiguration &, const QString &)>("connect_to_host_encrypted", &QNetworkAccessManager::connectToHostEncrypted, Arg("host_name"), Arg("port"), Arg("ssl_configuration"), Arg("peer_name"))
+            .define_method("cookie_jar", &QNetworkAccessManager::cookieJar)
+            .define_method("delete_resource", &QNetworkAccessManager::deleteResource, Arg("request"))
+            .define_method("enable_strict_transport_security_store", &QNetworkAccessManager::enableStrictTransportSecurityStore, Arg("enabled"), Arg("store_dir") = static_cast<const QString &>(QString()))
+            .define_method<QNetworkReply *(QNetworkAccessManager::*)(const QNetworkRequest &)>("get", &QNetworkAccessManager::get, Arg("request"))
+            .define_method<QNetworkReply *(QNetworkAccessManager::*)(const QNetworkRequest &, QIODevice *)>("get", &QNetworkAccessManager::get, Arg("request"), Arg("data"))
+            .define_method<QNetworkReply *(QNetworkAccessManager::*)(const QNetworkRequest &, const QByteArray &)>("get", &QNetworkAccessManager::get, Arg("request"), Arg("data"))
+            .define_method("head", &QNetworkAccessManager::head, Arg("request"))
+            .define_method("strict_transport_security_enabled?", &QNetworkAccessManager::isStrictTransportSecurityEnabled)
+            .define_method("strict_transport_security_store_enabled?", &QNetworkAccessManager::isStrictTransportSecurityStoreEnabled)
+            .define_method<QNetworkReply *(QNetworkAccessManager::*)(const QNetworkRequest &, QHttpMultiPart *)>("post", &QNetworkAccessManager::post, Arg("request"), Arg("multi_part"))
+            .define_method<QNetworkReply *(QNetworkAccessManager::*)(const QNetworkRequest &, QIODevice *)>("post", &QNetworkAccessManager::post, Arg("request"), Arg("data"))
+            .define_method<QNetworkReply *(QNetworkAccessManager::*)(const QNetworkRequest &, const QByteArray &)>("post", &QNetworkAccessManager::post, Arg("request"), Arg("data"))
+            // .define_method<QNetworkReply *(QNetworkAccessManager::*)(const QNetworkRequest &, std::nullptr_t)>("post", &QNetworkAccessManager::post, Arg("request"), Arg("data"))
+            .define_method("proxy", &QNetworkAccessManager::proxy)
+            .define_method("proxy_factory", &QNetworkAccessManager::proxyFactory)
+            .define_method<QNetworkReply *(QNetworkAccessManager::*)(const QNetworkRequest &, QHttpMultiPart *)>("put", &QNetworkAccessManager::put, Arg("request"), Arg("multi_part"))
+            .define_method<QNetworkReply *(QNetworkAccessManager::*)(const QNetworkRequest &, QIODevice *)>("put", &QNetworkAccessManager::put, Arg("request"), Arg("data"))
+            .define_method<QNetworkReply *(QNetworkAccessManager::*)(const QNetworkRequest &, const QByteArray &)>("put", &QNetworkAccessManager::put, Arg("request"), Arg("data"))
+            // .define_method<QNetworkReply *(QNetworkAccessManager::*)(const QNetworkRequest &, std::nullptr_t)>("put", &QNetworkAccessManager::put, Arg("request"), Arg("data"))
+            .define_method("redirect_policy", &QNetworkAccessManager::redirectPolicy)
+            .define_method<QNetworkReply *(QNetworkAccessManager::*)(const QNetworkRequest &, const QByteArray &, QHttpMultiPart *)>("send_custom_request", &QNetworkAccessManager::sendCustomRequest, Arg("request"), Arg("verb"), Arg("multi_part"))
+            .define_method<QNetworkReply *(QNetworkAccessManager::*)(const QNetworkRequest &, const QByteArray &, QIODevice *)>("send_custom_request", &QNetworkAccessManager::sendCustomRequest, Arg("request"), Arg("verb"), Arg("data") = static_cast<QIODevice *>(nullptr))
+            .define_method<QNetworkReply *(QNetworkAccessManager::*)(const QNetworkRequest &, const QByteArray &, const QByteArray &)>("send_custom_request", &QNetworkAccessManager::sendCustomRequest, Arg("request"), Arg("verb"), Arg("data"))
+            .define_method("set_auto_delete_replies", &QNetworkAccessManager::setAutoDeleteReplies, Arg("auto_delete"))
+            .define_method("set_cache", &QNetworkAccessManager::setCache, Arg("cache"))
+            .define_method("set_cookie_jar", &QNetworkAccessManager::setCookieJar, Arg("cookie_jar"))
+            .define_method("set_proxy", &QNetworkAccessManager::setProxy, Arg("proxy"))
+            .define_method("set_proxy_factory", &QNetworkAccessManager::setProxyFactory, Arg("factory"))
+            .define_method("set_redirect_policy", &QNetworkAccessManager::setRedirectPolicy, Arg("policy"))
+            .define_method("set_strict_transport_security_enabled", &QNetworkAccessManager::setStrictTransportSecurityEnabled, Arg("enabled"))
+            .define_method<void (QNetworkAccessManager::*)(int)>("set_transfer_timeout", &QNetworkAccessManager::setTransferTimeout, Arg("timeout"))
+            .define_method("strict_transport_security_hosts", &QNetworkAccessManager::strictTransportSecurityHosts)
+            .define_method("supported_schemes", &QNetworkAccessManager::supportedSchemes)
+            .define_method("transfer_timeout", &QNetworkAccessManager::transferTimeout)
+            .define_method("transfer_timeout_as_duration", &QNetworkAccessManager::transferTimeoutAsDuration);
+            // Signals
+            // .define_method("authentication_required", &QNetworkAccessManager::authenticationRequired, Arg("reply"), Arg("authenticator"))
+            // .define_method("encrypted", &QNetworkAccessManager::encrypted, Arg("reply"))
+            // .define_method("finished", &QNetworkAccessManager::finished, Arg("reply"))
+            // .define_method("pre_shared_key_authentication_required", &QNetworkAccessManager::preSharedKeyAuthenticationRequired, Arg("reply"), Arg("authenticator"))
+            // .define_method("proxy_authentication_required", &QNetworkAccessManager::proxyAuthenticationRequired, Arg("proxy"), Arg("authenticator"))
+            // .define_method("ssl_errors", &QNetworkAccessManager::sslErrors, Arg("reply"), Arg("errors"));
+    Data_Type<QNetworkAccessManager::Operation> rb_cQNetworkAccessManagerOperation =
+        // RubyQt6::QtNetwork::QNetworkAccessManager::Operation
+        define_qenum_under<QNetworkAccessManager::Operation>(rb_cQNetworkAccessManager, "Operation");
+        define_qenum_value_under(rb_cQNetworkAccessManagerOperation, "HeadOperation", QNetworkAccessManager::Operation::HeadOperation);
+        define_qenum_value_under(rb_cQNetworkAccessManagerOperation, "GetOperation", QNetworkAccessManager::Operation::GetOperation);
+        define_qenum_value_under(rb_cQNetworkAccessManagerOperation, "PutOperation", QNetworkAccessManager::Operation::PutOperation);
+        define_qenum_value_under(rb_cQNetworkAccessManagerOperation, "PostOperation", QNetworkAccessManager::Operation::PostOperation);
+        define_qenum_value_under(rb_cQNetworkAccessManagerOperation, "DeleteOperation", QNetworkAccessManager::Operation::DeleteOperation);
+        define_qenum_value_under(rb_cQNetworkAccessManagerOperation, "CustomOperation", QNetworkAccessManager::Operation::CustomOperation);
+        define_qenum_value_under(rb_cQNetworkAccessManagerOperation, "UnknownOperation", QNetworkAccessManager::Operation::UnknownOperation);
+}

data/ext/qt6/qtnetwork/qnetworkaccessmanager-rb.hpp ADDED Viewed

@@ -0,0 +1,5 @@
+#include <rice/qt6.hpp>
+RICE4RUBYQT6_USE_NAMESPACE
+void Init_qnetworkaccessmanager(Module rb_mQt6QtNetwork);

data/ext/qt6/qtnetwork/qnetworkreply-rb.cpp ADDED Viewed

@@ -0,0 +1,95 @@
+#include "qnetworkreply-rb.hpp"
+#include <qnetworkreply.h>
+#include <rice/qt6/qenum.hpp>
+RICE4RUBYQT6_USE_NAMESPACE
+Class rb_cQNetworkReply;
+void Init_qnetworkreply(Module rb_mQt6QtNetwork)
+{
+    rb_cQNetworkReply =
+        // RubyQt6::QtNetwork::QNetworkReply
+        define_class_under<QNetworkReply, QIODevice>(rb_mQt6QtNetwork, "QNetworkReply")
+            // RubyQt6-Defined Functions
+            .define_singleton_function("_qvariant_register_metatype", []() -> int { return qRegisterMetaType<QNetworkReply *>(); })
+            .define_singleton_function("_qvariant_from_value", [](QNetworkReply *value) -> QVariant { return QVariant::fromValue(value); })
+            .define_singleton_function("_qvariant_to_value", [](const QVariant &qvariant) -> QNetworkReply * { return qvariant.value<QNetworkReply *>(); })
+            .define_singleton_function("_static_meta_object", []() -> const QMetaObject * { return &QNetworkReply::staticMetaObject; })
+            // Public Functions
+            .define_method("attribute", &QNetworkReply::attribute, Arg("code"))
+            .define_method("close", &QNetworkReply::close)
+            .define_method("error", &QNetworkReply::error)
+            .define_method("has_raw_header", &QNetworkReply::hasRawHeader, Arg("header_name"))
+            .define_method("header", &QNetworkReply::header, Arg("header"))
+            .define_method("headers", &QNetworkReply::headers)
+            .define_method<void (QNetworkReply::*)(const QList<QSslError> &)>("ignore_ssl_errors", &QNetworkReply::ignoreSslErrors, Arg("errors"))
+            .define_method("finished?", &QNetworkReply::isFinished)
+            .define_method("running?", &QNetworkReply::isRunning)
+            .define_method("sequential?", &QNetworkReply::isSequential)
+            .define_method("manager", &QNetworkReply::manager)
+            .define_method("operation", &QNetworkReply::operation)
+            .define_method("raw_header", &QNetworkReply::rawHeader, Arg("header_name"))
+            .define_method("raw_header_list", &QNetworkReply::rawHeaderList)
+            .define_method("raw_header_pairs", &QNetworkReply::rawHeaderPairs)
+            .define_method("read_buffer_size", &QNetworkReply::readBufferSize)
+            .define_method("request", &QNetworkReply::request)
+            .define_method("set_read_buffer_size", &QNetworkReply::setReadBufferSize, Arg("size"))
+            .define_method("set_ssl_configuration", &QNetworkReply::setSslConfiguration, Arg("configuration"))
+            .define_method("ssl_configuration", &QNetworkReply::sslConfiguration)
+            .define_method("url", &QNetworkReply::url)
+            // Public Slots
+            .define_method("abort", &QNetworkReply::abort)
+            .define_method<void (QNetworkReply::*)()>("ignore_ssl_errors", &QNetworkReply::ignoreSslErrors);
+            // Signals
+            // .define_method("download_progress", &QNetworkReply::downloadProgress, Arg("bytes_received"), Arg("bytes_total"))
+            // .define_method("encrypted", &QNetworkReply::encrypted)
+            // .define_method("error_occurred", &QNetworkReply::errorOccurred, Arg("code"))
+            // .define_method("finished", &QNetworkReply::finished)
+            // .define_method("meta_data_changed", &QNetworkReply::metaDataChanged)
+            // .define_method("pre_shared_key_authentication_required", &QNetworkReply::preSharedKeyAuthenticationRequired, Arg("authenticator"))
+            // .define_method("redirect_allowed", &QNetworkReply::redirectAllowed)
+            // .define_method("redirected", &QNetworkReply::redirected, Arg("url"))
+            // .define_method("request_sent", &QNetworkReply::requestSent)
+            // .define_method("socket_started_connecting", &QNetworkReply::socketStartedConnecting)
+            // .define_method("ssl_errors", &QNetworkReply::sslErrors, Arg("errors"))
+            // .define_method("upload_progress", &QNetworkReply::uploadProgress, Arg("bytes_sent"), Arg("bytes_total"));
+    Data_Type<QNetworkReply::NetworkError> rb_cQNetworkReplyNetworkError =
+        // RubyQt6::QtNetwork::QNetworkReply::NetworkError
+        define_qenum_under<QNetworkReply::NetworkError>(rb_cQNetworkReply, "NetworkError");
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "NoError", QNetworkReply::NetworkError::NoError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "ConnectionRefusedError", QNetworkReply::NetworkError::ConnectionRefusedError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "RemoteHostClosedError", QNetworkReply::NetworkError::RemoteHostClosedError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "HostNotFoundError", QNetworkReply::NetworkError::HostNotFoundError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "TimeoutError", QNetworkReply::NetworkError::TimeoutError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "OperationCanceledError", QNetworkReply::NetworkError::OperationCanceledError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "SslHandshakeFailedError", QNetworkReply::NetworkError::SslHandshakeFailedError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "TemporaryNetworkFailureError", QNetworkReply::NetworkError::TemporaryNetworkFailureError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "NetworkSessionFailedError", QNetworkReply::NetworkError::NetworkSessionFailedError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "BackgroundRequestNotAllowedError", QNetworkReply::NetworkError::BackgroundRequestNotAllowedError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "TooManyRedirectsError", QNetworkReply::NetworkError::TooManyRedirectsError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "InsecureRedirectError", QNetworkReply::NetworkError::InsecureRedirectError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "UnknownNetworkError", QNetworkReply::NetworkError::UnknownNetworkError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "ProxyConnectionRefusedError", QNetworkReply::NetworkError::ProxyConnectionRefusedError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "ProxyConnectionClosedError", QNetworkReply::NetworkError::ProxyConnectionClosedError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "ProxyNotFoundError", QNetworkReply::NetworkError::ProxyNotFoundError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "ProxyTimeoutError", QNetworkReply::NetworkError::ProxyTimeoutError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "ProxyAuthenticationRequiredError", QNetworkReply::NetworkError::ProxyAuthenticationRequiredError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "UnknownProxyError", QNetworkReply::NetworkError::UnknownProxyError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "ContentAccessDenied", QNetworkReply::NetworkError::ContentAccessDenied);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "ContentOperationNotPermittedError", QNetworkReply::NetworkError::ContentOperationNotPermittedError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "ContentNotFoundError", QNetworkReply::NetworkError::ContentNotFoundError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "AuthenticationRequiredError", QNetworkReply::NetworkError::AuthenticationRequiredError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "ContentReSendError", QNetworkReply::NetworkError::ContentReSendError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "ContentConflictError", QNetworkReply::NetworkError::ContentConflictError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "ContentGoneError", QNetworkReply::NetworkError::ContentGoneError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "UnknownContentError", QNetworkReply::NetworkError::UnknownContentError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "ProtocolUnknownError", QNetworkReply::NetworkError::ProtocolUnknownError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "ProtocolInvalidOperationError", QNetworkReply::NetworkError::ProtocolInvalidOperationError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "ProtocolFailure", QNetworkReply::NetworkError::ProtocolFailure);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "InternalServerError", QNetworkReply::NetworkError::InternalServerError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "OperationNotImplementedError", QNetworkReply::NetworkError::OperationNotImplementedError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "ServiceUnavailableError", QNetworkReply::NetworkError::ServiceUnavailableError);
+        define_qenum_value_under(rb_cQNetworkReplyNetworkError, "UnknownServerError", QNetworkReply::NetworkError::UnknownServerError);
+}

data/ext/qt6/qtnetwork/qnetworkreply-rb.hpp ADDED Viewed

@@ -0,0 +1,5 @@
+#include <rice/qt6.hpp>
+RICE4RUBYQT6_USE_NAMESPACE
+void Init_qnetworkreply(Module rb_mQt6QtNetwork);

data/ext/qt6/qtnetwork/qnetworkrequest-rb.cpp ADDED Viewed

@@ -0,0 +1,142 @@
+#include "qnetworkrequest-rb.hpp"
+#include <qnetworkrequest.h>
+#include <rice/qt6/qenum.hpp>
+#include <QHttp1Configuration>
+#include <QHttp2Configuration>
+#include <QSslConfiguration>
+RICE4RUBYQT6_USE_NAMESPACE
+Class rb_cQNetworkRequest;
+void Init_qnetworkrequest(Module rb_mQt6QtNetwork)
+{
+    rb_cQNetworkRequest =
+        // RubyQt6::QtNetwork::QNetworkRequest
+        define_class_under<QNetworkRequest>(rb_mQt6QtNetwork, "QNetworkRequest")
+            // Constructor
+            .define_constructor(Constructor<QNetworkRequest>())
+            .define_constructor(Constructor<QNetworkRequest, const QUrl &>(), Arg("url"))
+            // Public Functions
+            .define_method("attribute", &QNetworkRequest::attribute, Arg("code"), Arg("default_value") = static_cast<const QVariant &>(QVariant()))
+            .define_method("decompressed_safety_check_threshold", &QNetworkRequest::decompressedSafetyCheckThreshold)
+            .define_method("has_raw_header", &QNetworkRequest::hasRawHeader, Arg("header_name"))
+            .define_method("header", &QNetworkRequest::header, Arg("header"))
+            .define_method("headers", &QNetworkRequest::headers)
+            .define_method("http1_configuration", &QNetworkRequest::http1Configuration)
+            .define_method("http2_configuration", &QNetworkRequest::http2Configuration)
+            .define_method("maximum_redirects_allowed", &QNetworkRequest::maximumRedirectsAllowed)
+            .define_method("originating_object", &QNetworkRequest::originatingObject)
+            .define_method("peer_verify_name", &QNetworkRequest::peerVerifyName)
+            .define_method("priority", &QNetworkRequest::priority)
+            .define_method("raw_header", &QNetworkRequest::rawHeader, Arg("header_name"))
+            .define_method("raw_header_list", &QNetworkRequest::rawHeaderList)
+            .define_method("set_attribute", &QNetworkRequest::setAttribute, Arg("code"), Arg("value"))
+            .define_method("set_decompressed_safety_check_threshold", &QNetworkRequest::setDecompressedSafetyCheckThreshold, Arg("threshold"))
+            .define_method("set_header", &QNetworkRequest::setHeader, Arg("header"), Arg("value"))
+            .define_method<void (QNetworkRequest::*)(QHttpHeaders &&)>("set_headers", &QNetworkRequest::setHeaders, Arg("new_headers"))
+            .define_method<void (QNetworkRequest::*)(const QHttpHeaders &)>("set_headers", &QNetworkRequest::setHeaders, Arg("new_headers"))
+            .define_method("set_http1_configuration", &QNetworkRequest::setHttp1Configuration, Arg("configuration"))
+            .define_method("set_http2_configuration", &QNetworkRequest::setHttp2Configuration, Arg("configuration"))
+            .define_method("set_maximum_redirects_allowed", &QNetworkRequest::setMaximumRedirectsAllowed, Arg("maximum_redirects_allowed"))
+            .define_method("set_originating_object", &QNetworkRequest::setOriginatingObject, Arg("object"))
+            .define_method("set_peer_verify_name", &QNetworkRequest::setPeerVerifyName, Arg("peer_name"))
+            .define_method("set_priority", &QNetworkRequest::setPriority, Arg("priority"))
+            .define_method("_set_raw_header", &QNetworkRequest::setRawHeader, Arg("header_name"), Arg("value"))
+            .define_method("set_ssl_configuration", &QNetworkRequest::setSslConfiguration, Arg("configuration"))
+            .define_method<void (QNetworkRequest::*)(int)>("set_transfer_timeout", &QNetworkRequest::setTransferTimeout, Arg("timeout"))
+            .define_method("set_url", &QNetworkRequest::setUrl, Arg("url"))
+            .define_method("ssl_configuration", &QNetworkRequest::sslConfiguration)
+            .define_method("transfer_timeout", &QNetworkRequest::transferTimeout)
+            .define_method("transfer_timeout_as_duration", &QNetworkRequest::transferTimeoutAsDuration)
+            .define_method("url", &QNetworkRequest::url);
+    Data_Type<QNetworkRequest::Attribute> rb_cQNetworkRequestAttribute =
+        // RubyQt6::QtNetwork::QNetworkRequest::Attribute
+        define_qenum_under<QNetworkRequest::Attribute>(rb_cQNetworkRequest, "Attribute");
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "HttpStatusCodeAttribute", QNetworkRequest::Attribute::HttpStatusCodeAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "HttpReasonPhraseAttribute", QNetworkRequest::Attribute::HttpReasonPhraseAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "RedirectionTargetAttribute", QNetworkRequest::Attribute::RedirectionTargetAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "ConnectionEncryptedAttribute", QNetworkRequest::Attribute::ConnectionEncryptedAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "CacheLoadControlAttribute", QNetworkRequest::Attribute::CacheLoadControlAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "CacheSaveControlAttribute", QNetworkRequest::Attribute::CacheSaveControlAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "SourceIsFromCacheAttribute", QNetworkRequest::Attribute::SourceIsFromCacheAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "DoNotBufferUploadDataAttribute", QNetworkRequest::Attribute::DoNotBufferUploadDataAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "HttpPipeliningAllowedAttribute", QNetworkRequest::Attribute::HttpPipeliningAllowedAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "HttpPipeliningWasUsedAttribute", QNetworkRequest::Attribute::HttpPipeliningWasUsedAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "CustomVerbAttribute", QNetworkRequest::Attribute::CustomVerbAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "CookieLoadControlAttribute", QNetworkRequest::Attribute::CookieLoadControlAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "AuthenticationReuseAttribute", QNetworkRequest::Attribute::AuthenticationReuseAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "CookieSaveControlAttribute", QNetworkRequest::Attribute::CookieSaveControlAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "MaximumDownloadBufferSizeAttribute", QNetworkRequest::Attribute::MaximumDownloadBufferSizeAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "DownloadBufferAttribute", QNetworkRequest::Attribute::DownloadBufferAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "SynchronousRequestAttribute", QNetworkRequest::Attribute::SynchronousRequestAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "BackgroundRequestAttribute", QNetworkRequest::Attribute::BackgroundRequestAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "EmitAllUploadProgressSignalsAttribute", QNetworkRequest::Attribute::EmitAllUploadProgressSignalsAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "Http2AllowedAttribute", QNetworkRequest::Attribute::Http2AllowedAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "Http2WasUsedAttribute", QNetworkRequest::Attribute::Http2WasUsedAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "OriginalContentLengthAttribute", QNetworkRequest::Attribute::OriginalContentLengthAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "RedirectPolicyAttribute", QNetworkRequest::Attribute::RedirectPolicyAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "Http2DirectAttribute", QNetworkRequest::Attribute::Http2DirectAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "ResourceTypeAttribute", QNetworkRequest::Attribute::ResourceTypeAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "AutoDeleteReplyOnFinishAttribute", QNetworkRequest::Attribute::AutoDeleteReplyOnFinishAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "ConnectionCacheExpiryTimeoutSecondsAttribute", QNetworkRequest::Attribute::ConnectionCacheExpiryTimeoutSecondsAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "Http2CleartextAllowedAttribute", QNetworkRequest::Attribute::Http2CleartextAllowedAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "UseCredentialsAttribute", QNetworkRequest::Attribute::UseCredentialsAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "FullLocalServerNameAttribute", QNetworkRequest::Attribute::FullLocalServerNameAttribute);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "User", QNetworkRequest::Attribute::User);
+        define_qenum_value_under(rb_cQNetworkRequestAttribute, "UserMax", QNetworkRequest::Attribute::UserMax);
+    Data_Type<QNetworkRequest::CacheLoadControl> rb_cQNetworkRequestCacheLoadControl =
+        // RubyQt6::QtNetwork::QNetworkRequest::CacheLoadControl
+        define_qenum_under<QNetworkRequest::CacheLoadControl>(rb_cQNetworkRequest, "CacheLoadControl");
+        define_qenum_value_under(rb_cQNetworkRequestCacheLoadControl, "AlwaysNetwork", QNetworkRequest::CacheLoadControl::AlwaysNetwork);
+        define_qenum_value_under(rb_cQNetworkRequestCacheLoadControl, "PreferNetwork", QNetworkRequest::CacheLoadControl::PreferNetwork);
+        define_qenum_value_under(rb_cQNetworkRequestCacheLoadControl, "PreferCache", QNetworkRequest::CacheLoadControl::PreferCache);
+        define_qenum_value_under(rb_cQNetworkRequestCacheLoadControl, "AlwaysCache", QNetworkRequest::CacheLoadControl::AlwaysCache);
+    Data_Type<QNetworkRequest::KnownHeaders> rb_cQNetworkRequestKnownHeaders =
+        // RubyQt6::QtNetwork::QNetworkRequest::KnownHeaders
+        define_qenum_under<QNetworkRequest::KnownHeaders>(rb_cQNetworkRequest, "KnownHeaders");
+        define_qenum_value_under(rb_cQNetworkRequestKnownHeaders, "ContentTypeHeader", QNetworkRequest::KnownHeaders::ContentTypeHeader);
+        define_qenum_value_under(rb_cQNetworkRequestKnownHeaders, "ContentLengthHeader", QNetworkRequest::KnownHeaders::ContentLengthHeader);
+        define_qenum_value_under(rb_cQNetworkRequestKnownHeaders, "LocationHeader", QNetworkRequest::KnownHeaders::LocationHeader);
+        define_qenum_value_under(rb_cQNetworkRequestKnownHeaders, "LastModifiedHeader", QNetworkRequest::KnownHeaders::LastModifiedHeader);
+        define_qenum_value_under(rb_cQNetworkRequestKnownHeaders, "CookieHeader", QNetworkRequest::KnownHeaders::CookieHeader);
+        define_qenum_value_under(rb_cQNetworkRequestKnownHeaders, "SetCookieHeader", QNetworkRequest::KnownHeaders::SetCookieHeader);
+        define_qenum_value_under(rb_cQNetworkRequestKnownHeaders, "ContentDispositionHeader", QNetworkRequest::KnownHeaders::ContentDispositionHeader);
+        define_qenum_value_under(rb_cQNetworkRequestKnownHeaders, "UserAgentHeader", QNetworkRequest::KnownHeaders::UserAgentHeader);
+        define_qenum_value_under(rb_cQNetworkRequestKnownHeaders, "ServerHeader", QNetworkRequest::KnownHeaders::ServerHeader);
+        define_qenum_value_under(rb_cQNetworkRequestKnownHeaders, "IfModifiedSinceHeader", QNetworkRequest::KnownHeaders::IfModifiedSinceHeader);
+        define_qenum_value_under(rb_cQNetworkRequestKnownHeaders, "ETagHeader", QNetworkRequest::KnownHeaders::ETagHeader);
+        define_qenum_value_under(rb_cQNetworkRequestKnownHeaders, "IfMatchHeader", QNetworkRequest::KnownHeaders::IfMatchHeader);
+        define_qenum_value_under(rb_cQNetworkRequestKnownHeaders, "IfNoneMatchHeader", QNetworkRequest::KnownHeaders::IfNoneMatchHeader);
+        define_qenum_value_under(rb_cQNetworkRequestKnownHeaders, "NumKnownHeaders", QNetworkRequest::KnownHeaders::NumKnownHeaders);
+    Data_Type<QNetworkRequest::LoadControl> rb_cQNetworkRequestLoadControl =
+        // RubyQt6::QtNetwork::QNetworkRequest::LoadControl
+        define_qenum_under<QNetworkRequest::LoadControl>(rb_cQNetworkRequest, "LoadControl");
+        define_qenum_value_under(rb_cQNetworkRequestLoadControl, "Automatic", QNetworkRequest::LoadControl::Automatic);
+        define_qenum_value_under(rb_cQNetworkRequestLoadControl, "Manual", QNetworkRequest::LoadControl::Manual);
+    Data_Type<QNetworkRequest::Priority> rb_cQNetworkRequestPriority =
+        // RubyQt6::QtNetwork::QNetworkRequest::Priority
+        define_qenum_under<QNetworkRequest::Priority>(rb_cQNetworkRequest, "Priority");
+        define_qenum_value_under(rb_cQNetworkRequestPriority, "HighPriority", QNetworkRequest::Priority::HighPriority);
+        define_qenum_value_under(rb_cQNetworkRequestPriority, "NormalPriority", QNetworkRequest::Priority::NormalPriority);
+        define_qenum_value_under(rb_cQNetworkRequestPriority, "LowPriority", QNetworkRequest::Priority::LowPriority);
+    Data_Type<QNetworkRequest::RedirectPolicy> rb_cQNetworkRequestRedirectPolicy =
+        // RubyQt6::QtNetwork::QNetworkRequest::RedirectPolicy
+        define_qenum_under<QNetworkRequest::RedirectPolicy>(rb_cQNetworkRequest, "RedirectPolicy");
+        define_qenum_value_under(rb_cQNetworkRequestRedirectPolicy, "ManualRedirectPolicy", QNetworkRequest::RedirectPolicy::ManualRedirectPolicy);
+        define_qenum_value_under(rb_cQNetworkRequestRedirectPolicy, "NoLessSafeRedirectPolicy", QNetworkRequest::RedirectPolicy::NoLessSafeRedirectPolicy);
+        define_qenum_value_under(rb_cQNetworkRequestRedirectPolicy, "SameOriginRedirectPolicy", QNetworkRequest::RedirectPolicy::SameOriginRedirectPolicy);
+        define_qenum_value_under(rb_cQNetworkRequestRedirectPolicy, "UserVerifiedRedirectPolicy", QNetworkRequest::RedirectPolicy::UserVerifiedRedirectPolicy);
+    Data_Type<QNetworkRequest::TransferTimeoutConstant> rb_cQNetworkRequestTransferTimeoutConstant =
+        // RubyQt6::QtNetwork::QNetworkRequest::TransferTimeoutConstant
+        define_qenum_under<QNetworkRequest::TransferTimeoutConstant>(rb_cQNetworkRequest, "TransferTimeoutConstant");
+        define_qenum_value_under(rb_cQNetworkRequestTransferTimeoutConstant, "DefaultTransferTimeoutConstant", QNetworkRequest::TransferTimeoutConstant::DefaultTransferTimeoutConstant);
+}

data/ext/qt6/qtnetwork/qnetworkrequest-rb.hpp ADDED Viewed

@@ -0,0 +1,5 @@
+#include <rice/qt6.hpp>
+RICE4RUBYQT6_USE_NAMESPACE
+void Init_qnetworkrequest(Module rb_mQt6QtNetwork);

data/ext/qt6/qtnetwork/qtnetwork-rb.cpp CHANGED Viewed

@@ -2,6 +2,10 @@
 #include "qtnetworkversion-rb.hpp"
 #include "qnetworkproxy-rb.hpp"
+#include "qnetworkrequest-rb.hpp"
+#include "qnetworkaccessmanager-rb.hpp"
+#include "qnetworkreply-rb.hpp"
 #include "t-qtnetwork-rb.hpp"
@@ -16,6 +20,10 @@ extern "C" void Init_qtnetwork()
         Init_qtnetworkversion(rb_mQt6QtNetwork);
         Init_qnetworkproxy(rb_mQt6QtNetwork);
+        Init_qnetworkrequest(rb_mQt6QtNetwork);
+        Init_qnetworkaccessmanager(rb_mQt6QtNetwork);
+        Init_qnetworkreply(rb_mQt6QtNetwork);
         Module rb_mQt6T = define_module_under(rb_mQt6, "T");
         Init_t_qtnetwork(rb_mQt6T);

data/lib/qt6/qtnetwork/qnetworkaccessmanager.rb ADDED Viewed

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module RubyQt6
+  module QtNetwork
+    # @see https://doc.qt.io/qt-6/qnetworkaccessmanager.html
+    class QNetworkAccessManager < RubyQt6::QtCore::QObject
+      # @!parse class Operation; end
+      rubyqt6_declare_enum_under QNetworkAccessManager, QNetworkAccessManager::Operation
+      # @!parse
+      q_object do
+        signal "authenticationRequired(QNetworkReply*,QAuthenticator*)"
+        signal "encrypted(QNetworkReply*)"
+        signal "finished(QNetworkReply*)"
+        signal "preSharedKeyAuthenticationRequired(QNetworkReply*,QSslPreSharedKeyAuthenticator*)"
+        signal "proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)"
+        signal "sslErrors(QNetworkReply*,QList<QSslError>)"
+      end
+      # @!visibility private
+      alias_method :_initialize, :initialize
+      # @param parent [QObject]
+      # @return [QNetworkAccessManager]
+      def initialize(parent = nil)
+        _initialize(parent)
+        _take_ownership_from_ruby(self)
+      end
+    end
+  end
+end

data/lib/qt6/qtnetwork/qnetworkreply.rb ADDED Viewed

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module RubyQt6
+  module QtNetwork
+    # @see https://doc.qt.io/qt-6/qnetworkreply.html
+    class QNetworkReply < RubyQt6::QtCore::QIODevice
+      # @!parse class NetworkError; end
+      rubyqt6_declare_enum_under QNetworkReply, QNetworkReply::NetworkError
+      # @!parse
+      QtCore::QVariant.register(
+        _qvariant_register_metatype,
+        method(:_qvariant_from_value),
+        method(:_qvariant_to_value),
+        from: self
+      )
+      # @!parse
+      q_object do
+        signal "downloadProgress(qlonglong,qlonglong)"
+        signal "encrypted()"
+        signal "errorOccurred(QNetworkReply::NetworkError)"
+        signal "finished()"
+        signal "metaDataChanged()"
+        signal "preSharedKeyAuthenticationRequired(QSslPreSharedKeyAuthenticator*)"
+        signal "redirectAllowed()"
+        signal "redirected(QUrl)"
+        signal "requestSent()"
+        signal "socketStartedConnecting()"
+        signal "sslErrors(QList<QSslError>)"
+        signal "uploadProgress(qlonglong,qlonglong)"
+        slot "abort()"
+        slot "ignoreSslErrors()"
+      end
+    end
+  end
+end

data/lib/qt6/qtnetwork/qnetworkrequest.rb ADDED Viewed

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+module RubyQt6
+  module QtNetwork
+    # @see https://doc.qt.io/qt-6/qnetworkrequest.html
+    class QNetworkRequest
+      # @!parse class Attribute              ; end
+      # @!parse class CacheLoadControl       ; end
+      # @!parse class KnownHeaders           ; end
+      # @!parse class LoadControl            ; end
+      # @!parse class Priority               ; end
+      # @!parse class RedirectPolicy         ; end
+      # @!parse class TransferTimeoutConstant; end
+      rubyqt6_declare_enum_under QNetworkRequest, QNetworkRequest::Attribute
+      rubyqt6_declare_enum_under QNetworkRequest, QNetworkRequest::CacheLoadControl
+      rubyqt6_declare_enum_under QNetworkRequest, QNetworkRequest::KnownHeaders
+      rubyqt6_declare_enum_under QNetworkRequest, QNetworkRequest::LoadControl
+      rubyqt6_declare_enum_under QNetworkRequest, QNetworkRequest::Priority
+      rubyqt6_declare_enum_under QNetworkRequest, QNetworkRequest::RedirectPolicy
+      rubyqt6_declare_enum_under QNetworkRequest, QNetworkRequest::TransferTimeoutConstant
+      # @!visibility private
+      alias_method :_initialize, :initialize
+      # @return [QNetworkRequest]
+      #
+      # @overload initialize
+      #
+      # @overload initialize(url)
+      #   @param url [QUrl]
+      def initialize(*args)
+        _initialize(*args)
+      end
+      # @!visibility private
+      def set_raw_header(header_name, value)
+        _set_raw_header(T.to_qbytearray(header_name), T.to_qbytearray(value))
+      end
+    end
+  end
+end

data/lib/qt6/qtnetwork/version.rb CHANGED Viewed

@@ -2,6 +2,6 @@
 module RubyQt6
   module QtNetwork
-    QTNETWORK_RUBYGEM_VERSION = "2.0.0"
+    QTNETWORK_RUBYGEM_VERSION = "2.0.1"
   end
 end

data/lib/qt6/qtnetwork.rb CHANGED Viewed

@@ -9,3 +9,7 @@ require_relative "qtnetwork/qtnetworkversion"
 require_relative "qtnetwork/qnetworkproxy"
 require_relative "qtnetwork/qnetworkproxyquery"
 require_relative "qtnetwork/qnetworkproxyfactory"
+require_relative "qtnetwork/qnetworkrequest"
+require_relative "qtnetwork/qnetworkaccessmanager"
+require_relative "qtnetwork/qnetworkreply"

metadata CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-qt6-qtnetwork
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.0.1
 platform: ruby
 authors:
 - John Doe
@@ -51,8 +51,14 @@ files:
 - README.md
 - Rakefile
 - ext/qt6/qtnetwork/extconf.rb
+- ext/qt6/qtnetwork/qnetworkaccessmanager-rb.cpp
+- ext/qt6/qtnetwork/qnetworkaccessmanager-rb.hpp
 - ext/qt6/qtnetwork/qnetworkproxy-rb.cpp
 - ext/qt6/qtnetwork/qnetworkproxy-rb.hpp
+- ext/qt6/qtnetwork/qnetworkreply-rb.cpp
+- ext/qt6/qtnetwork/qnetworkreply-rb.hpp
+- ext/qt6/qtnetwork/qnetworkrequest-rb.cpp
+- ext/qt6/qtnetwork/qnetworkrequest-rb.hpp
 - ext/qt6/qtnetwork/qtnetwork-rb.cpp
 - ext/qt6/qtnetwork/qtnetwork-rb.hpp
 - ext/qt6/qtnetwork/qtnetworkversion-rb.cpp
@@ -60,9 +66,12 @@ files:
 - ext/qt6/qtnetwork/t-qtnetwork-rb.cpp
 - ext/qt6/qtnetwork/t-qtnetwork-rb.hpp
 - lib/qt6/qtnetwork.rb
+- lib/qt6/qtnetwork/qnetworkaccessmanager.rb
 - lib/qt6/qtnetwork/qnetworkproxy.rb
 - lib/qt6/qtnetwork/qnetworkproxyfactory.rb
 - lib/qt6/qtnetwork/qnetworkproxyquery.rb
+- lib/qt6/qtnetwork/qnetworkreply.rb
+- lib/qt6/qtnetwork/qnetworkrequest.rb
 - lib/qt6/qtnetwork/qtnetworkversion.rb
 - lib/qt6/qtnetwork/version.rb
 homepage: https://github.com/souk4711/ruby-qt6