dub 0.10.3 → 1.0.0

data/lib/dub/argument.rb

@@ -0,0 +1,286 @@
+require 'dub/entities_unescape'
+
+module Dub
+  class Argument
+    include Dub::EntitiesUnescape
+    attr_reader :name, :default, :function, :xml
+    attr_accessor :type, :is_list, :is_list_count
+    TYPE_REGEXP = %r{^\s*(\w+\s+|)(const\s+|)([\w\:]+|\.\.\.)(\s*<(.+)>|)(\s*\*+|\s*&|)$}
+    NUMBER_TYPES = [
+      'float',
+      'double',
+      'size_t',
+      'unsigned int',
+      'uint',
+      'int',
+      'size_t',
+      'time_t',
+      'unsigned int',
+      'uint',
+      'bool',
+      'uchar',
+      'void',
+      'int64',
+    ]
+
+    STRING_TYPES = [
+      'char',
+    ]
+
+    BOOL_TYPES = [
+      'bool',
+    ]
+
+    NATIVE_C_TYPES = NUMBER_TYPES + STRING_TYPES + BOOL_TYPES
+
+    class << self
+
+      # This is used to resolve overloaded functions
+      def type_group(arg)
+        # exact same type
+        if NATIVE_C_TYPES.include?(arg.type)
+          if BOOL_TYPES.include?(arg.type)
+            :boolean
+          elsif STRING_TYPES.include?(arg.type) && arg.is_pointer?
+            :string
+          else
+            # number synonym
+            arg.is_pointer? ? :number_ptr : :number
+          end
+        else
+          # custom class / type
+          arg.id_name
+        end
+      end
+
+      # group is a list of functions, index = argument index
+      def decision_tree(group)
+        hash = {}
+        group.each do |function|
+          insert_by_arg(hash, function)
+        end
+        hash
+      end
+
+      # Insert a function into the hash, using the argument at the given
+      # index to filter
+      def insert_by_arg(hash, function, index = 0)
+        arg  = function.arguments[index]
+        type = arg ? type_group(arg) : nil
+        insert_by_type(hash, function, index, type)
+        if arg && arg.has_default?
+          insert_by_type(hash, function, index, nil)
+        end
+      end
+
+      def insert_by_type(hash, function, index, type)
+        # hash[nil] ==> there is a default argument
+        slot = hash[type]
+        if slot.nil?
+          hash[type] = function
+        elsif slot.kind_of?(Hash)
+          insert_by_arg(slot, function, index + 1)
+        elsif type.nil?
+          # ignore
+
+          # TODO: log level
+          # puts "Cannot filter functions #{function.source}"
+        else
+          h = {}
+          insert_by_arg(h, slot, index + 1)
+          insert_by_arg(h, function, index + 1)
+          hash[type] = h
+        end
+      end
+    end
+
+    def initialize(function, xml, arg_pos = nil)
+      @function, @xml, @argument_position = function, xml, arg_pos
+      parse_xml
+    end
+
+    def signature
+      "#{is_const? ? 'const ' : ''}#{type}#{is_ref? ? '&' : ''}"
+    end
+
+    def full_type
+      if type =~ /::/
+        type
+      else
+        container = function.parent
+        if container.kind_of?(Klass)
+          container = container.parent
+        end
+        container ? "#{container.name}::#{type}" : type
+      end
+    end
+
+    def id_name
+      full_type.gsub('::', '.')
+    end
+
+    alias inspect signature
+
+    def is_ref?
+      @ref
+    end
+
+    def is_pointer?
+      !@pointer.nil?
+    end
+
+    def is_const?
+      @const
+    end
+
+    def has_default?
+      !@default.nil?
+    end
+
+    def is_return_value?
+      @is_return_value
+    end
+
+    def is_native?
+      NATIVE_C_TYPES.include?(type)
+    end
+
+    def type
+      resolve_type if @template_params
+      @type
+    end
+
+    def vararg?
+      @type == '...'
+    end
+
+    def complex?
+      resolve_type if @template_params
+      @is_complex
+    end
+
+    def is_list?
+      @is_list
+    end
+
+    def is_list_count?
+      @is_list_count
+    end
+
+    def create_type
+      resolve_type if @template_params
+      (is_const? ? 'const ' : '') +
+      if (is_return_value? && !is_pointer?) || (is_native? && !is_pointer?)
+        "#{type} "
+      else
+        "#{type} *"
+      end
+    end
+
+    # this is for the cases where we have signatures like
+    # HuMoments(double moments[7])
+    def array_suffix
+      @array_suffix
+    end
+
+    def in_call_type
+      (is_native? || is_pointer?) ? name : "*#{name}"
+    end
+
+    private
+      def parse_xml
+        if type = (@xml/'type').first
+          # param
+          set_type(type)
+
+          @name = unescape((@xml/'declname').innerHTML)
+          if @name == ''
+            @name = "arg#{@argument_position}"
+          elsif @name == @function.name
+            @name = "arg_#{@name}"
+          end
+
+          if ref = (@xml/'defval/ref').first
+            ref.swap(ref.innerHTML)
+          end
+          @default = (@xml/'defval') ? unescape((@xml/'defval').innerHTML) : nil
+          @default = nil if @default == ''
+          expand_default_type if @default
+        else
+          # return value
+          @is_return_value = true
+          set_type(@xml/'')
+        end
+
+        if array = (@xml/'array').first
+          @array_suffix = array.innerHTML
+        end
+      end
+
+      def set_type(type)
+        # <type>const <ref refid="classcv_1_1_point__" kindref="compound">Point_</ref>&lt; int &gt; &amp;</type>
+        if ref = (type/'ref').first
+          @refid = ref[:refid]
+          ref.swap(ref.innerHTML)
+        end
+
+        type = type.innerHTML
+        type = unescape(type).strip
+
+        if type =~ TYPE_REGEXP
+          res = $~.to_a
+
+          if res[1].strip == 'const'
+            res[2] = res[1]
+            res[1] = ""
+          end
+
+          @const = res[2].strip == 'const'
+          @type = res[3]
+
+          if res[6] == ''
+            @pointer = nil
+            @res = nil
+          elsif res[6] =~ /^\s*(\*+)\s*$/
+            @pointer = $1
+          else
+            @ref = res[6].strip
+          end
+
+          @template_params = res[5] ? res[5].split(',').map(&:strip) : nil
+        else
+          # ERROR
+        end
+      end
+
+      # Replace something like AUTO_STEP by cv::Mat::AUTO_STEP
+      def expand_default_type
+        container = @function.parent
+        if container && container.enums.include?(@default)
+          @default = "#{container.full_type}::#{@default}"
+        elsif container = container.parent && container.enums.include?(@default)
+          @default = "#{container.full_type}::#{@default}"
+        end
+      end
+
+      def resolve_type
+        params = @template_params
+        @template_params = nil
+        if container = @function.parent
+          if container.kind_of?(Klass)
+            container = container.parent
+          end
+          if container && tclass = container.template_class(@type)
+            if instanciation = tclass.instanciations[params]
+              @type = instanciation.name
+              return
+            end
+          end
+        end
+
+        @type = "#{@type}< #{params.join(', ')} >"
+        Dub.logger.warn "Could not resolve templated type #{@type}"
+        @is_complex = true
+      end
+  end
+end # Namespace

data/lib/dub/entities_unescape.rb

@@ -0,0 +1,9 @@
+require 'htmlentities'
+module Dub
+  module EntitiesUnescape
+    Decoder = HTMLEntities.new
+    def unescape(str)
+      Decoder.decode(str)
+    end
+  end
+end

data/lib/dub/function.rb

@@ -0,0 +1,177 @@
+require 'dub/argument'
+require 'dub/entities_unescape'
+
+module Dub
+  class Function
+    include Dub::EntitiesUnescape
+    attr_reader :arguments, :prefix, :return_value, :xml, :parent
+    attr_accessor :gen, :name, :is_constructor, :overloaded_index
+
+    def initialize(parent, name, xml, prefix = '')
+      @parent, @name = parent, name
+      @xml, @prefix = xml, prefix
+      parse_xml
+      parse_template_params
+    end
+
+    def set_as_constructor
+      @return_value = Argument.new(self, (Hpricot::XML("<type>#{name} *</type>")/''))
+      @is_constructor = true
+    end
+
+    def bind(generator)
+      @gen = generator.function_generator
+    end
+
+    def to_s
+      generator.function(self)
+    end
+
+    def generator
+      @gen || (@parent && @parent.function_generator)
+    end
+
+    def klass
+      @parent.kind_of?(Klass) ? @parent : nil
+    end
+
+    def member_method?
+      !klass.nil?
+    end
+
+    def constructor?
+      @is_constructor
+    end
+
+    def throws?
+      @throw ||= (@xml/'exceptions').innerHTML || ''
+      @throw = (@throw =~ /throw\s*\(\s*\)/) ? :nothing : :any
+      @throw != :nothing
+    end
+
+    def custom_body(lang)
+      klass ? klass.custom_bind(lang)[self.name] : nil
+    end
+
+    def static?
+      @is_static
+    end
+
+    alias gen generator
+
+    def name=(n)
+      @name = n
+      if constructor?
+        @return_value.type = n
+      end
+    end
+
+    def call_name
+      if klass
+        static? ? "#{klass.name}::#{name}" : name
+      else
+        name
+      end
+    end
+
+    def id_name
+      @parent ? "#{@parent.id_name}.#{name}" : name
+    end
+
+    def source
+      loc = (@xml/'location').first.attributes
+      "#{loc['file'].split('/')[-3..-1].join('/')}:#{loc['line']}"
+    end
+
+    def original_signature
+      unescape "#{(@xml/'definition').innerHTML}#{(@xml/'argsstring').innerHTML}"
+    end
+
+    def has_default_arguments?
+      return @has_defaults if defined?(@has_defaults)
+      @has_defaults = !@arguments.detect {|a| a.has_default? }.nil?
+    end
+
+    def has_array_arguments?
+      return @has_array_arguments if defined?(@has_array_arguments)
+      @has_array_arguments = !@arguments.detect {|a| a.array_suffix }.nil?
+    end
+
+    def has_class_pointer_arguments?
+      return @has_class_pointer_arguments if defined?(@has_class_pointer_arguments)
+      @has_class_pointer_arguments = !@arguments.detect {|a| !a.is_native? && a.is_pointer? }.nil?
+    end
+
+    def has_complex_arguments?
+      return @has_complex_arguments if defined?(@has_complex_arguments)
+      @has_complex_arguments = !(@arguments + [@return_value]).compact.detect {|a| a.complex? }.nil?
+    end
+
+    def vararg?
+      @arguments.last && @arguments.last.vararg?
+    end
+
+    def arg_is_list(list_position, count_position)
+      @arguments[list_position ].is_list       = true
+      @arguments[count_position].is_list_count = true
+    end
+
+    def template?
+      !@template_params.nil?
+    end
+
+    def public?
+      @xml[:prot] == 'public'
+    end
+
+    def template_params
+      @template_params
+    end
+
+    def inspect
+      "#<Function #{@prefix}_#{@name}(#{@arguments.inspect[1..-2]})>"
+    end
+
+    def <=>(other)
+      name <=> other.name
+    end
+
+    # ====== these methods are alias to
+    # generator methods on this object
+
+    def method_name(overloaded_index = nil)
+      gen.method_name(self, overloaded_index)
+    end
+
+    # =================================
+
+    private
+      def parse_xml
+        @arguments = []
+
+        (@xml/'param').each_with_index do |arg, i|
+          @arguments << Argument.new(self, arg, i + 1)
+        end
+
+        raw_type = (@xml/'/type').innerHTML
+
+        if raw_type.strip == ''
+          # no return type
+        else
+          arg = Argument.new(self, (@xml/'/type'))
+          @return_value = arg unless arg.create_type =~ /void\s*$/
+        end
+
+        @is_static = @xml[:static] == 'yes'
+      end
+
+      def parse_template_params
+        template_params = (@xml/'/templateparamlist/param')
+        if !template_params.empty?
+          @template_params = template_params.map do |param|
+            (param/'/type').innerHTML.gsub(/^\s*(typename|class)\s+/,'')
+          end
+        end
+      end
+  end
+end # Namespace

data/lib/dub/function_group.rb

@@ -0,0 +1,72 @@
+module Dub
+  class FunctionGroup < Array
+    def initialize(parent, gen = nil)
+      @parent, @gen = parent, gen
+    end
+
+    def bind(generator)
+      self.gen = generator.function_generator
+    end
+
+    def generator
+      @gen || (@parent && @parent.function_generator)
+    end
+
+    def gen=(generator)
+      @gen = generator
+      @gen_members = nil
+    end
+
+    alias gen generator
+
+    def members
+      if self.generator
+        if @parent.generator
+          @gen_members ||= @parent.generator.members_list(self)
+        else
+          @gen_members ||= generator.namespace_generator.members_list(self)
+        end
+      else
+        self
+      end
+    end
+
+    def to_s
+      generator.group(self)
+    end
+
+    def method_name(overloaded_index = nil)
+      first.method_name(overloaded_index)
+    end
+
+    def map(&block)
+      list = self.class.new(@parent, @gen)
+      super(&block).each do |e|
+        list << e
+      end
+      list
+    end
+
+    def compact
+      list = self.class.new(@parent, @gen)
+      super.each do |e|
+        list << e
+      end
+      list
+    end
+
+    def overloaded_index
+      nil
+    end
+
+    def <=>(other)
+      name <=> other.name
+    end
+
+    private
+      def method_missing(method, *args)
+        first.send(method, *args)
+      end
+
+  end
+end

data/lib/dub/generator.rb

@@ -0,0 +1,15 @@
+require 'dub/function'
+
+module Dub
+  class Generator
+
+    def comment(func)
+      "/** #{func.original_signature}\n * #{func.source}\n */"
+    end
+
+    protected
+      def indent(str, indent)
+        str.gsub(/^/, ' ' * indent)
+      end
+  end # Generator
+end # Dub

data/lib/dub/group.rb

@@ -0,0 +1,20 @@
+require 'dub/namespace'
+
+module Dub
+  class Group < Namespace
+    def parse_xml
+      super
+      parse_defines
+    end
+
+    def arg_is_list(argument_pos, count_pos)
+      each do |f|
+        f.arg_is_list(argument_pos, count_pos)
+      end
+    end
+
+    def constructor?
+      f.first.constructor?
+    end
+  end
+end