wxruby3 0.9.0.pre.beta.8

data/rakelib/lib/extractor/class.rb

@@ -0,0 +1,384 @@
+###
+# wxRuby3 wxWidgets interface extractor
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  module Extractor
+
+    class SuperDef
+      def self.[](name, *supers, mod: nil)
+        self.new(name, *supers, mod: mod)
+      end
+
+      def self.create_super_def(spec)
+        case spec
+        when SuperDef
+          spec
+        when ::Hash
+          name, mod = spec.first
+          SuperDef[name, mod: mod]
+        else
+          SuperDef[spec.to_s]
+        end
+      end
+
+      def self.build_inheritance_chain(*supers)
+        return SuperDef[nil] if supers.empty?
+        base = create_super_def(supers.shift)
+        base.add_super(build_inheritance_chain(*supers)) unless supers.empty?
+        base
+      end
+
+      def self.build_hierarchy(*supers)
+        supers.inject({}) do |h, p|
+          sd = create_super_def(p)
+          h[sd.name] = sd
+          h
+        end
+      end
+
+      def initialize(name, *supers, mod: nil)
+        @name = name
+        @module = mod
+        @supers = SuperDef.build_hierarchy(*supers)
+      end
+
+      attr_reader :name, :supers
+
+      def module
+        @module ? @module : @name
+      end
+
+      def add_super(spr, *supers, mod: nil)
+        if SuperDef === spr
+          @supers[spr.name] = spr
+        else
+          @supers[spr.to_s] = SuperDef.new(spr.to_s, *supers, mod: mod)
+        end
+      end
+
+      def get_super(name)
+        @supers[name]
+      end
+
+      def to_s
+        "{#{name}#{@module ? "@#{@module}" : ''} < #{@supers.values.join(', ')}}"
+      end
+
+      def inspect
+        to_s
+      end
+    end
+
+    # The information about a class that is needed to generate wrappers for it.
+    class ClassDef < BaseDef
+
+      include Util::StringUtil
+
+      NAME_TAG = 'compoundname'
+
+      IGNORED_BASES = ['wxTrackable']
+
+      def initialize(element = nil, kind = 'class', **kwargs)
+        super()
+        @kind = kind
+        @protection = 'public'
+        @template_params = [] # class is a template
+        @bases = [] # base class names
+        @sub_classes = [] # sub classes
+        @hierarchy = {}
+        @includes = [] # .h file for this class
+        @abstract = false # is it an abstract base class?
+        @no_def_ctor = false # do not generate a default constructor
+        @innerclasses = []
+        @is_inner = false # Is this a nested class?
+        @klass = nil # if so, then this is the outer class
+        @event = false # if so, is wxEvent derived class
+        @event_list = false # if so, class has emitted events specified
+        @event_types = []
+        @param_mappings = []
+        @crossref_table = {}
+
+        update_attributes(**kwargs)
+        extract(element) if element
+      end
+
+      attr_accessor :kind, :protection, :template_params, :bases, :sub_classes, :hierarchy, :includes, :abstract,
+                    :no_def_ctor, :innerclasses, :is_inner, :klass, :event, :event_list, :event_types, :crossref_table
+
+      def is_template?
+        !template_params.empty?
+      end
+
+      def get_hierarchy(element)
+        this = nil
+        index = {}
+        # collect
+        graph = element.at_xpath('inheritancegraph')
+        if graph
+          graph.xpath('node'). each do |node|
+            node_name = node.at_xpath('label').text
+            unless IGNORED_BASES.include?(node_name)
+              node_supers = node.xpath('childnode').collect { |cn|  cn['refid'] }
+              sd = SuperDef[node_name]
+              index[node['id']] = [sd, node_supers]
+              this = sd if @name == node_name
+            end
+          end
+          # resolve
+          index.each_value do |(sd, ns)|
+            ns.each { |sid| sd.add_super(index[sid].first) if index.has_key?(sid) }
+          end
+        end
+        this ? this.supers : {}
+      end
+
+      def find_base(bases, name)
+        return bases[name] if bases.has_key?(name)
+        bases.each_value do |base|
+          if (base = find_base(base.supers, name))
+            return base
+          end
+        end
+        nil
+      end
+      private :find_base
+
+      def is_derived_from?(classname)
+        !!find_base(@hierarchy, classname)
+      end
+
+      def add_crossrefs(element)
+        element.xpath('listofallmembers/member').each do |node|
+          crossref_table[node['refid']] = { scope: node.at_xpath('scope').text, name: node.at_xpath('name').text }
+        end
+      end
+      private :add_crossrefs
+
+      def extract(element)
+        super
+
+        check_deprecated
+        # @node_bases = find_hierarchy(element, {}, [], false)
+        @hierarchy = get_hierarchy(element)
+
+        element.xpath('basecompoundref').each { |node| @bases << node.text }
+        element.xpath('derivedcompoundref').each { |node| @sub_classes << node.text }
+        element.xpath('includes').each { |node| @includes << node.text }
+        element.xpath('templateparamlist/param').each do |node|
+          if node.at_xpath('declname')
+            txt = node.at_xpath('declname').text
+          else
+            txt = node.at_xpath('type').text
+            txt.sub!('class ', '')
+            txt.sub!('typename ', '')
+          end
+          @template_params << txt
+        end
+
+        if is_derived_from?('wxEvent')
+          @event = true
+          if /Event macros(\s+for\s+events\s+emitted\s+by\s+this\s+class)?:/ =~ detailed_doc.text
+            detailed_doc.xpath('.//listitem').each do |li|
+              if li.text =~ /(EVT_\w+)\W*\((.*)\)/
+                evt_handler = $1
+                args = $2.split(',').collect {|a| a.strip }
+                # skip event macros with event type argument
+                unless args.any? { |a| a == 'event' }
+                  # determine evt_type handled
+                  evt_type = if li.text =~ /(Process\s+a|Respond\s+to)\s+wx(\w+)\s+/
+                               $2
+                             else
+                               evt_handler
+                             end
+                  # record event handler (macro) name, event type handled and the number of event id arguments
+                  evt_arity = args.inject(0) {|c, a| c += 1 if a.start_with?('id'); c }
+                  @event_types << [evt_handler, evt_type, evt_arity]
+                end
+              end
+            end
+          end
+        else
+          evt_heading = detailed_doc.xpath('.//heading').find {|h| h.text == 'Events emitted by this class'}
+          if evt_heading
+            @event_list = true
+            evt_paras = evt_heading.xpath('parent::para').first.xpath('following-sibling::para')
+            if (evt_paras.size>1 &&
+                  (evt_paras[0].text.start_with?('The following event handler macros redirect') ||
+                    evt_paras[0].text.start_with?('Event macros for events emitted by this class:')))
+              evt_klass = if (evt_ref = evt_paras[0].at('./ref'))
+                            evt_ref.text
+                          else
+                            nil
+                          end
+              evt_paras[1].xpath('.//listitem').each do |li|
+                if li.text =~ /(EVT_\w+)\((.*)\)/
+                  evt_handler = $1
+                  args = $2.split(',').collect {|a| a.strip }
+                  # skip event macros with event type argument
+                  unless args.any? { |a| a == 'event' }
+                    # determine evt_type handled
+                    evt_type = if li.text =~ /Process\s+a\s+wx(\w+)\s+/
+                                 $1
+                               else
+                                 evt_handler
+                               end
+                    # record event handler (macro) name, event type handled and the number of event id arguments
+                    evt_arity = args.inject(0) {|c, a| c += 1 if a.start_with?('id'); c }
+                    @event_types << [evt_handler, evt_type, evt_arity, evt_klass]
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        element.xpath('innerclass').each do |node|
+          unless node['prot'] == 'private'
+            ref = node['refid']
+            fname = File.join(Extractor.xml_dir, ref + '.xml')
+            root = File.open(fname) { |f| Nokogiri::XML(f).root }
+            innerclass = root.elements.first
+            kind = innerclass['kind']
+            unless %w[class struct].include?(kind)
+              raise ExtractorError.new("Invalid innerclass kind [#{kind}]")
+            end
+            item = ClassDef.new(innerclass, kind, gendoc: self.gendoc)
+            item.protection = node['prot']
+            item.is_inner = true
+            item.klass = self # This makes a reference cycle but it's okay
+            item.ignore if item.protection == 'protected' # ignore by default
+            @innerclasses << item
+          end
+        end
+
+        # TODO: Is it possible for there to be memberdef's w/o a sectiondef?
+        member = nil
+        element.xpath('sectiondef/memberdef').each do |node|
+          # skip any private items
+          unless node['prot'] == 'private'
+            case _kind = node['kind']
+            when 'function'
+              Extractor.extracting_msg(_kind, node)
+              member = MethodDef.new(node, self.name, klass: self, gendoc: self.gendoc)
+              #@abstract = true if m.is_pure_virtual
+              unless member.check_for_overload(self.items)
+                self.items << member
+              end
+            when 'variable'
+              Extractor.extracting_msg(_kind, node)
+              member = MemberVarDef.new(node, gendoc: self.gendoc)
+              self.items << member
+            when 'enum'
+              Extractor.extracting_msg(_kind, node)
+              member = EnumDef.new(node, scope: self.name, gendoc: self.gendoc)
+              self.items << member
+            when 'typedef'
+              Extractor.extracting_msg(_kind, node)
+              member = TypedefDef.new(node, gendoc: self.gendoc)
+              self.items << member
+            when 'friend'
+              # noop
+            else
+              raise ExtractorError.new('Unknown memberdef kind: %s' % _kind)
+            end
+            # ignore protected members by default
+            member.ignore if member.protection == 'protected'
+          end
+        end
+
+        add_crossrefs(element) if self.gendoc
+
+        # make abstract unless the class has at least 1 public ctor
+        ctor = self.items.find {|m| MethodDef === m && m.is_ctor }
+        unless ctor && (ctor.protection == 'public' || ctor.overloads.any? {|ovl| ovl.protection == 'public' })
+          @abstract = true
+        end
+      end
+
+      def regards_protected_members?
+        self.items.any? {|item| !item.ignored && item.protection == 'protected' }
+      end
+
+      def add_param_mapping(from, to)
+        @param_mappings << FunctionDef::ParamMapping.new(from, to)
+      end
+
+      def find_param_mapping(paramdefs)
+        @param_mappings.detect { |pm| pm.matches?(paramdefs) }
+      end
+
+      def methods
+        ::Enumerator.new { |y| items.each {|i|  y << i if MethodDef === i }}
+      end
+
+      def aliases
+        methods.select do |mtd|
+          # exclude ctor/dtor and static and methods
+          rc = false
+          unless mtd.is_ctor || mtd.is_dtor || mtd.is_static
+            mtd_ovls = mtd.all.select { |ovl| !ovl.ignored } # only consider non-ignored
+            # only consider methods without overloads or where all overloads have either
+            # not been renamed or have all been renamed identically
+            # (SWIG %rename does not work well with %alias in these cases so leave those
+            # for WxRubyStyleAccessors to handle at runtime)
+            last_nm = nil
+            rc = !mtd_ovls.empty? &&
+              (mtd_ovls.size==1 ||
+                mtd_ovls.all? { |ovl| !ovl.rb_name } ||
+                mtd_ovls.inject(::Set.new) { |set, ovl| set << ovl.rb_name }.size==1)
+            if rc
+              mtd = mtd_ovls.first
+              mtd_name = mtd.rb_name || mtd.name
+              unless (rc = (/\A(Is|Has|Can)[A-Z]/ =~ mtd_name))
+                unless (rc = (/\A(is|has|can)_\w+\Z/ =~ mtd_name))
+                  if /\A(Get[A-Z]|get_\w)/ =~ mtd_name
+                    # since getters have no decoration ('=' or '?') a C++ method with the same
+                    # name could exist already; check this and exclude if so
+                    alias_name = mtd_name.sub(/\A(Get|get_)/, '')
+                    rc = !methods.any? { |m| !m.ignored && rb_method_name(alias_name) == m.rb_decl_name }
+                  elsif /\A(Set[A-Z]|set_\w)/ =~ mtd_name
+                    # only consider setter aliases (xxx=) in case at least one method overload
+                    # accepts only a single argument
+                    rc = mtd_ovls.any? { |ovl| ovl.parameter_count>0 && ovl.required_param_count<2 }
+                  end
+                end
+              end
+              if rc
+                # check there is not a static method with the same name; SWIG alias handling chokes on that
+                rc = !methods.any? { |m| !m.ignored && m.is_static && m.name == mtd_name}
+              end
+            end
+          end
+          rc
+        end.collect do |mtd|
+          mtd = mtd.all.select { |ovl| !ovl.ignored }.shift
+          mtd_name = mtd.rb_name || mtd.name
+          case mtd_name
+          when /\A(Get|get_)/
+            [mtd.name, rb_method_name(mtd_name.sub(/\A(Get|get_)/, ''), keep_wx_prefix: true)]
+          when /\A(Set|set_)/
+            [mtd.name, rb_method_name(mtd_name.sub(/\A(Set|set_)/, ''), keep_wx_prefix: true)+'=']
+          when /\A(Is|is_)/
+            [mtd.name, rb_method_name(mtd_name.sub(/\A(Is|is_)/, ''), keep_wx_prefix: true)+'?']
+          else # when /\A(Has|Can|has_|can_)/
+            [mtd.name, rb_method_name(mtd_name)+'?']
+          end
+        end.to_h
+      end
+
+      def all_methods
+        ::Enumerator::Chain.new(*methods.collect {|m| m.all })
+      end
+
+      def _find_items
+        self.items + self.innerclasses
+      end
+
+    end # class ClassDef
+
+  end # module Extractor
+
+end # module WXRuby3

data/rakelib/lib/extractor/enum.rb

@@ -0,0 +1,94 @@
+###
+# wxRuby3 wxWidgets interface extractor
+# Copyright (c) M.J.N. Corino, The Netherlands
+###
+
+module WXRuby3
+
+  module Extractor
+
+    # A named or anonymous enumeration.
+    class EnumDef < BaseDef
+
+      class << self
+        def enums(hash = nil)
+          @enums = hash if hash
+          @enums ||= ::Hash.new
+        end
+
+        def register(enum)
+          enums[enum.name] = enum.scope || '' # assumes all wxWidgets enums (even scoped) are uniquely named
+        end
+
+        def enum?(name)
+          enums.has_key?(name)
+        end
+
+        def enum_scope(name)
+          enums[name]
+        end
+      end
+
+      def initialize(element = nil, **kwargs)
+        super()
+        @strong = false
+        @protection = 'public'
+        extract(element) if element
+        @scope = ''
+        @no_type = false
+        update_attributes(**kwargs)
+        EnumDef.register(self) unless is_anonymous
+      end
+
+      attr_accessor :is_anonymous, :protection, :scope, :strong
+
+      def extract(element)
+        super
+        prot = element['prot']
+        if prot
+          @protection = prot
+          unless %w[public protected].include?(@protection)
+            raise ExtractorError.new("Invalid protection [#{@protection}")
+          end
+          # TODO: Should protected items be ignored by default or should we
+          #       leave that up to the tweaker code or the generators?
+          ignore if @protection == 'protected'
+        end
+        @is_anonymous = name.start_with?('@') || name.empty?
+        @strong = (element['strong'] == 'yes') unless @is_anonymous
+        element.xpath('enumvalue').each do |node|
+          value = EnumValueDef.new(node, enum: self)
+          items << value
+        end
+      end
+
+      def is_type
+        !@is_anonymous
+      end
+    end # class EnumDef
+
+    # An item in an enumeration.
+    class EnumValueDef < BaseDef
+      def initialize(element = nil, **kwargs)
+        super()
+        @value = nil
+        update_attributes(**kwargs)
+        extract(element) if element
+      end
+
+      def extract(element)
+        super
+        @value = BaseDef.flatten_node(element.at_xpath('initializer'))
+      end
+
+      attr_reader :value
+
+      def fqn
+        enum.strong ? "#{enum.name}::#{name}" : name
+      end
+
+    end # class EnumValueDef
+
+  end # module Extractor
+
+end # module WXRuby3