qt 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b47b66563f703c260222b8ac0e38f2bf27e4ee654dd3152181bb8866e93e182
-  data.tar.gz: 797218dab7d7ce473510b05bd500c8151503b0ebc018648c5d82a5e5abb7e8f0
+  metadata.gz: 50d48e8571c76d7413f893a6189b7670629bd3a80123a131bf9cc00ffe6d818e
+  data.tar.gz: bcb0081e9ebabc04175f7f041fdf8442293d08191e5ee6e2b26164d32c730942
 SHA512:
-  metadata.gz: 37e94ba0242411ddd9f46d6858f397f53e2d2d62e38ba7ccba9a15fc517f86291b015d82dd359dfe0eb5ce12a011ebeb379d95a23c607c1be299883d5c24ed2a
-  data.tar.gz: 5fc3cc069da9615f8efb690d2888f5ec7f5c02422885e070331b4e271381405a082993c705d100c9e30b6ceb5661471701769c81e5ff6ff072024fe34c7b9c15
+  metadata.gz: 82bde56dd8d499bfc122923554109e6f7f92dfea399ed6fd2f821737c29cfb487b0025908409273aeb13df2ca9ed57a36eb524142a968c24a84eba43af4836b3
+  data.tar.gz: 0444cabcb5c8ce71559758e92168f0f357de967edaaf15671f5f867f7e115dc48615e49de6d4d9a3fa55c7d098da46460b810ec0ac07ff625922c724daeac575

data/README.md

@@ -301,6 +301,12 @@ Native event-runtime debug logs:
 QT_RUBY_EVENT_DEBUG=1 ruby your_app.rb
 ```
 
+Object-wrapper fallback debug logs:
+
+```bash
+QT_RUBY_OBJECT_WRAPPER_DEBUG=1 ruby your_app.rb
+```
+
 Optional tuning:
 
 ```bash

data/ext/qt_ruby_bridge/extconf.rb

@@ -6,6 +6,11 @@ require 'fileutils'
 PKG_CONFIG = RbConfig::CONFIG['PKG_CONFIG'] || 'pkg-config'
 QT_PACKAGES = %w[Qt6Core Qt6Gui Qt6Widgets].freeze
 MINIMUM_QT_VERSION = Gem::Version.new('6.4.2')
+ROOT = File.expand_path('../..', __dir__)
+GENERATOR = File.join(ROOT, 'scripts/generate_bridge.rb')
+GENERATED_CPP = File.join(ROOT, 'build/generated/qt_ruby_bridge.cpp')
+GENERATED_EVENT_PAYLOADS = File.join(ROOT, 'build/generated/event_payloads.inc')
+LOCAL_CPP = File.expand_path('qt_ruby_bridge.cpp')
 
 def pkg_config(*)
   system(PKG_CONFIG, *, out: File::NULL, err: File::NULL)
@@ -15,15 +20,27 @@ def pkg_config_capture(*args)
   `#{[PKG_CONFIG, *args].join(' ')}`.strip
 end
 
-abort 'pkg-config is required to build qt-ruby bridge.' unless find_executable(PKG_CONFIG)
+def generated_bridge_inputs_available?
+  (File.exist?(LOCAL_CPP) || File.exist?(GENERATED_CPP)) && File.exist?(GENERATED_EVENT_PAYLOADS)
+end
+
+def generator_env
+  scope = ENV.fetch('QT_RUBY_SCOPE', nil)
+  scope && !scope.empty? ? { 'QT_RUBY_SCOPE' => scope } : {}
+end
+
+def ensure_generated_bridge_inputs!
+  return false if generated_bridge_inputs_available?
 
-generator = File.expand_path('../../scripts/generate_bridge.rb', __dir__)
-abort "Generator script not found: #{generator}" unless File.exist?(generator)
+  abort "Generator script not found: #{GENERATOR}" unless File.exist?(GENERATOR)
+  abort 'Failed to generate Qt bridge files.' unless system(generator_env, RbConfig.ruby, GENERATOR)
+
+  true
+end
+
+abort 'pkg-config is required to build qt-ruby bridge.' unless find_executable(PKG_CONFIG)
 
-generator_env = {}
-scope = ENV.fetch('QT_RUBY_SCOPE', nil)
-generator_env['QT_RUBY_SCOPE'] = scope if scope && !scope.empty?
-abort 'Failed to generate Qt bridge files.' unless system(generator_env, RbConfig.ruby, generator)
+generated_by_extconf = ensure_generated_bridge_inputs!
 
 missing = QT_PACKAGES.reject { |pkg| pkg_config('--exists', pkg) }
 abort "Missing Qt packages: #{missing.join(', ')}" unless missing.empty?
@@ -34,10 +51,10 @@ abort "Qt version #{qt_version} is too old. Require >= #{MINIMUM_QT_VERSION}." i
 
 cflags = pkg_config_capture('--cflags', *QT_PACKAGES)
 libs = pkg_config_capture('--libs', *QT_PACKAGES)
-generated_cpp = if File.exist?('qt_ruby_bridge.cpp')
-                  File.expand_path('qt_ruby_bridge.cpp')
+generated_cpp = if !generated_by_extconf && File.exist?(LOCAL_CPP)
+                  LOCAL_CPP
                 else
-                  File.expand_path('../../build/generated/qt_ruby_bridge.cpp', __dir__)
+                  GENERATED_CPP
                 end
 runtime_hpp = File.expand_path('../../ext/qt_ruby_bridge/qt_ruby_runtime.hpp', __dir__)
 runtime_cpp_files = %w[
@@ -52,8 +69,7 @@ abort "Runtime header not found: #{runtime_hpp}" unless File.exist?(runtime_hpp)
 missing_runtime = runtime_cpp_files.reject { |path| File.exist?(path) }
 abort "Runtime source not found: #{missing_runtime.join(', ')}" unless missing_runtime.empty?
 
-local_cpp = File.expand_path('qt_ruby_bridge.cpp')
-FileUtils.cp(generated_cpp, local_cpp) unless File.exist?(local_cpp) && File.identical?(generated_cpp, local_cpp)
+FileUtils.cp(generated_cpp, LOCAL_CPP) unless File.exist?(LOCAL_CPP) && File.identical?(generated_cpp, LOCAL_CPP)
 runtime_cpp_files.each do |runtime_cpp|
   local_runtime_cpp = File.expand_path(File.basename(runtime_cpp))
   unless File.exist?(local_runtime_cpp) && File.identical?(runtime_cpp, local_runtime_cpp)

data/lib/qt/object_wrapper.rb

@@ -20,7 +20,10 @@ module Qt
       return cached if cached
 
       klass = resolve_wrapper_class(pointer, expected_qt_class) || fallback_wrapper_class(expected_qt_class)
-      return pointer unless klass
+      unless klass
+        warn_unwrapped_pointer(pointer, expected_qt_class)
+        return pointer
+      end
 
       register_wrapper(instantiate_wrapper(klass, pointer))
     end
@@ -113,6 +116,7 @@ module Qt
     def reset_cache!
       @wrapper_cache = {}
       @destroy_hook_addresses = {}
+      @unwrapped_pointer_warning_keys = {}
     end
 
     def install_constructor_cache_hooks!
@@ -132,6 +136,33 @@ module Qt
       @destroy_hook_addresses ||= {}
     end
 
+    def object_wrapper_debug_enabled?
+      ENV['QT_RUBY_OBJECT_WRAPPER_DEBUG'] == '1'
+    end
+
+    def warn_unwrapped_pointer(pointer, expected_qt_class)
+      return unless object_wrapper_debug_enabled?
+
+      label = warning_qt_class_label(expected_qt_class)
+      return if unwrapped_pointer_warning_keys[label]
+
+      unwrapped_pointer_warning_keys[label] = true
+      warn "[qt-ruby-wrapper] returning raw pointer for #{label}; no generated wrapper class matched " \
+           "address=0x#{pointer.address.to_s(16)}"
+    end
+
+    def warning_qt_class_label(expected_qt_class)
+      normalized = normalize_expected_qt_class(expected_qt_class)
+      return normalized if normalized
+
+      raw = expected_qt_class.to_s.strip
+      raw.empty? ? '(unknown Qt class)' : raw
+    end
+
+    def unwrapped_pointer_warning_keys
+      @unwrapped_pointer_warning_keys ||= {}
+    end
+
     def ensure_destroy_hook(wrapper, pointer)
       address = pointer.address
       return if destroy_hook_addresses[address]

data/lib/qt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Qt
-  VERSION = '0.1.8'
+  VERSION = '0.1.9'
 end

data/scripts/generate_bridge/core_utils.rb

@@ -109,6 +109,10 @@ def ctor_function_name(spec)
   "qt_ruby_#{spec[:prefix]}_new"
 end
 
-def method_function_name(spec, method)
+def default_method_function_name(spec, method)
   "qt_ruby_#{spec[:prefix]}_#{to_snake(method[:qt_name])}"
 end
+
+def method_function_name(spec, method)
+  method[:native_name] || default_method_function_name(spec, method)
+end

data/scripts/generate_bridge/spec_discovery.rb

@@ -151,6 +151,90 @@ def discover_related_value_classes(ast, seed_classes, all_classes, template_clas
   discovered.to_a
 end
 
+def discover_related_qobject_wrapper_classes(ast, seed_classes, all_classes, template_classes, scope)
+  discovered = seed_classes.to_set
+  queue = seed_classes.dup
+  related = []
+
+  until queue.empty?
+    klass = queue.shift
+    related_qobject_pointer_type_names(ast, klass).each do |candidate|
+      next if discovered.include?(candidate)
+      next unless related_qobject_wrapper_candidate?(ast, candidate, all_classes, template_classes, scope)
+
+      discovered << candidate
+      related << candidate
+      queue << candidate
+    end
+  end
+
+  related
+end
+
+def related_qobject_wrapper_candidate?(ast, qt_class, all_classes, template_classes, scope)
+  return false unless all_classes.include?(qt_class)
+  return false if template_classes.include?(qt_class)
+  return false if qt_class.end_with?('Private')
+  return false if qt_class == 'QApplication'
+  return false unless class_inherits?(ast, qt_class, 'QObject')
+
+  related_qobject_wrapper_matches_scope?(ast, qt_class, scope)
+end
+
+def related_qobject_wrapper_matches_scope?(ast, qt_class, scope)
+  case scope
+  when 'widgets'
+    class_inherits?(ast, qt_class, 'QWidget') || class_inherits?(ast, qt_class, 'QLayout')
+  when 'qobject'
+    !class_inherits?(ast, qt_class, 'QWidget') && !class_inherits?(ast, qt_class, 'QLayout')
+  when 'all'
+    true
+  else
+    raise "Unsupported QT_RUBY_SCOPE=#{scope.inspect}. Supported: #{SUPPORTED_SCOPES.join(', ')}"
+  end
+end
+
+def related_qobject_pointer_type_names(ast, qt_class)
+  int_cast_types = ast_int_cast_type_set(ast)
+  method_decls_for_related_wrapper_scan(ast, qt_class).each_with_object(Set.new) do |decl, out|
+    next unless auto_method_decl_candidate?(decl)
+    next unless auto_method_supported_for_related_wrapper_scan?(ast, decl, qt_class, int_cast_types)
+
+    parsed = parse_method_signature(decl)
+    append_qobject_pointer_types_from_decl(out, parsed)
+  end
+end
+
+def method_decls_for_related_wrapper_scan(ast, qt_class)
+  collect_method_names_with_bases(ast, qt_class).flat_map do |method_name|
+    collect_method_decls_with_bases(ast, qt_class, method_name)
+  end
+end
+
+def auto_method_supported_for_related_wrapper_scan?(ast, decl, qt_class, int_cast_types)
+  entry = { qt_name: decl['name'] }
+  !build_auto_method_from_decl(decl, entry, qt_class: qt_class, int_cast_types: int_cast_types, ast: ast).nil?
+end
+
+def append_qobject_pointer_types_from_decl(out, parsed)
+  pointer_type = qobject_pointer_type_name(parsed[:return_type])
+  out << pointer_type if pointer_type
+  parsed[:params].each do |param|
+    pointer_type = qobject_pointer_type_name(param[:type])
+    out << pointer_type if pointer_type
+  end
+end
+
+def qobject_pointer_type_name(raw_type)
+  normalized = normalized_cpp_type_name(raw_type).to_s
+  return nil unless normalized.end_with?('*')
+
+  type_name = normalized.delete_suffix('*')
+  return nil unless type_name.match?(/\AQ[A-Z]\w*\z/)
+
+  type_name
+end
+
 def related_value_class_candidate?(ast, qt_class, all_classes, template_classes)
   return false if SCALAR_BRIDGED_QT_TYPES.include?(qt_class)
   return false unless all_classes.include?(qt_class)
@@ -215,9 +299,13 @@ def discover_target_qt_classes(ast, scope)
   targets = timed("discover_target_qt_classes/#{scope}/related") do
     discover_related_value_classes(ast, base_targets, all_classes, template_classes).sort
   end
+  wrapper_targets = timed("discover_target_qt_classes/#{scope}/related_qobject_wrappers") do
+    discover_related_qobject_wrapper_classes(ast, targets, all_classes, template_classes, scope).sort
+  end
+  targets = (targets + wrapper_targets).uniq.sort
   debug_log(
     "discover_target_qt_classes scope=#{scope} total_q=#{all_classes.length} " \
-    "base=#{base_targets.length} targets=#{targets.length}"
+    "base=#{base_targets.length} wrappers=#{wrapper_targets.length} targets=#{targets.length}"
   )
   targets
 end
@@ -264,7 +352,7 @@ def constructor_usable_for_codegen?(ast, qt_class)
   ctor_decls = collect_constructor_decls(ast, qt_class)
   ctor_decls.any? do |decl|
     constructor_keysequence_parent_type(decl) ||
-    constructor_supports_parent_only?(decl) ||
+      constructor_supports_parent_only?(decl) ||
       constructor_supports_no_args?(decl) ||
       constructor_supports_string_path?(decl)
   end
@@ -272,28 +360,40 @@ end
 
 def build_base_spec_for_qt_class(ast, qt_class)
   ctor_decls = collect_constructor_decls(ast, qt_class)
+  parent_ctor = if abstract_class?(ast, qt_class)
+                  { parent: false, mode: :wrap_only }
+                else
+                  constructor_spec_for_qt_class(ast, qt_class, ctor_decls)
+                end
+  base_spec_hash(qt_class, parent_ctor)
+end
+
+def constructor_spec_for_qt_class(ast, qt_class, ctor_decls)
   keysequence_parent_type = ctor_decls.filter_map { |decl| constructor_keysequence_parent_type(decl) }.first
   parent_type = ctor_decls.filter_map { |decl| parent_constructor_first_type(decl) }.first
-  string_path_cast = ctor_decls.filter_map do |decl|
+  string_path_cast = constructor_string_path_cast(ctor_decls)
+  widget_child = qt_class != 'QWidget' && class_inherits?(ast, qt_class, 'QWidget')
+
+  if keysequence_parent_type
+    { parent: true, parent_type: keysequence_parent_type, mode: :keysequence_parent, register_in_parent: widget_child }
+  elsif parent_type
+    parent_constructor_for_type(parent_type, widget_child)
+  elsif string_path_cast
+    string_path_constructor(string_path_cast)
+  elsif ctor_decls.any? { |decl| constructor_supports_no_args?(decl) }
+    { parent: false }
+  else
+    { parent: false, mode: :wrap_only }
+  end
+end
+
+def constructor_string_path_cast(ctor_decls)
+  ctor_decls.filter_map do |decl|
     parsed = parse_method_signature(decl)
     next nil unless parsed && parsed[:params].first
 
     constructor_string_like_arg_cast(parsed[:params].first[:type])
   end.first
-  widget_child = qt_class != 'QWidget' && class_inherits?(ast, qt_class, 'QWidget')
-  parent_ctor =
-    if keysequence_parent_type
-      { parent: true, parent_type: keysequence_parent_type, mode: :keysequence_parent, register_in_parent: widget_child }
-    elsif parent_type
-      parent_constructor_for_type(parent_type, widget_child)
-    elsif string_path_cast
-      string_path_constructor(string_path_cast)
-    elsif ctor_decls.any? { |decl| constructor_supports_no_args?(decl) }
-      { parent: false }
-    else
-      { parent: false, mode: :wrap_only }
-    end
-  base_spec_hash(qt_class, parent_ctor)
 end
 
 def base_spec_hash(qt_class, parent_ctor)

data/scripts/generate_bridge.rb

@@ -920,13 +920,50 @@ end
 def append_ruby_widget_methods(lines, spec)
   spec[:methods].each do |method|
     call_args = ['@handle'] + method[:args].map { |arg| arg[:name] }
-    native_call = "Native.#{spec[:prefix]}_#{to_snake(method[:qt_name])}(#{call_args.join(', ')})"
+    native_name = method_function_name(spec, method).delete_prefix('qt_ruby_')
+    native_call = "Native.#{native_name}(#{call_args.join(', ')})"
     append_ruby_native_call_method(lines, method: method, native_call: native_call, indent: '    ')
     append_ruby_property_writer(lines, method: method, indent: '    ')
     lines << ''
   end
 end
 
+def assign_unique_native_method_names(specs)
+  used = Set.new
+  specs.map do |spec|
+    methods = spec[:methods].map do |method|
+      assign_unique_native_method_name(spec, method, used)
+    end
+    spec.merge(methods: methods)
+  end
+end
+
+def assign_unique_native_method_name(spec, method, used)
+  native_name = default_method_function_name(spec, method)
+  return used_add_and_return(used, native_name, method) unless used.include?(native_name)
+
+  unique_name = next_unique_native_method_name(spec, method, used)
+  debug_log("native name collision #{native_name} -> #{unique_name}")
+  used << unique_name
+  method.merge(native_name: unique_name)
+end
+
+def used_add_and_return(used, value, result)
+  used << value
+  result
+end
+
+def next_unique_native_method_name(spec, method, used)
+  base = "qt_ruby_#{spec[:prefix]}_qt_#{to_snake(method[:qt_name])}"
+  candidate = base
+  counter = 2
+  while used.include?(candidate)
+    candidate = "#{base}_#{counter}"
+    counter += 1
+  end
+  candidate
+end
+
 def generate_ruby_widget_class(lines, spec, specs_by_qt, super_qt_by_qt, qt_to_ruby)
   metadata = ruby_api_metadata_for_spec(spec, specs_by_qt, super_qt_by_qt)
   super_ruby = ruby_super_class_for_spec(spec, super_qt_by_qt, qt_to_ruby)
@@ -1202,7 +1239,8 @@ free_function_specs = timed('build_free_function_specs') { qt_free_function_spec
 base_specs = timed('build_base_specs') { build_base_specs(ast) }
 timed('validate_qt_api') { validate_qt_api!(ast, base_specs) }
 expanded_specs = timed('expand_auto_methods') { expand_auto_methods(base_specs, ast) }
-effective_specs = timed('enrich_specs_with_properties') { enrich_specs_with_properties(expanded_specs, ast) }
+property_specs = timed('enrich_specs_with_properties') { enrich_specs_with_properties(expanded_specs, ast) }
+effective_specs = timed('assign_unique_native_method_names') { assign_unique_native_method_names(property_specs) }
 super_qt_by_qt, wrapper_qt_classes = timed('build_generated_inheritance') do
   build_generated_inheritance(ast, effective_specs)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: qt
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Maksim Veynberg
@@ -100,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.9
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Ruby bindings for Qt 6.4.2+
 test_files: []