dub 0.10.3 → 1.0.0

data/lib/dub/member_extraction.rb

@@ -0,0 +1,128 @@
+require 'dub/function'
+require 'dub/function_group'
+require 'dub/klass'
+
+module Dub
+  class Klass
+  end
+
+  # This module is used by Namespace and Klass to extract member functions
+  module MemberExtraction
+    def members_prefix
+      @name
+    end
+
+    def parse_members
+      @members_hash   = {}
+      @t_members_hash = {}
+      # TODO: template functions
+      (@xml/'memberdef').each do |member|
+        Dub.logger.info "Parsing #{(member/'name').innerHTML}"
+        name = (member/"name").innerHTML
+        if (member/'templateparamlist').first
+          insert_member(member, name, @t_members_hash)
+        else
+          insert_member(member, name, @members_hash)
+        end
+      end
+    end
+
+    def insert_member(member, name, destination)
+      if destination[name].kind_of?(Array)
+        destination[name] << member
+      elsif first_member = destination[name]
+        destination[name] = [first_member, member]
+      else
+        destination[name] = member
+      end
+    end
+
+    def member(name)
+      get_member(name.to_s, @members_hash)
+    end
+
+    def members(ignore_list = [])
+      @members ||= begin
+        list = []
+        @members_hash.each do |name, member|
+          next if ignore_list.include?(name)
+          list << get_member(name)
+        end
+        list.compact!
+        list.sort
+      end
+    end
+
+    def template_method(name)
+      get_member(name.to_s, @t_members_hash)
+    end
+
+    # Lazy construction of members
+    def get_member(name, source = @members_hash)
+      if member_or_group = source[name]
+        if member_or_group.kind_of?(Array)
+          if member_or_group.first.kind_of?(Hpricot::Elem)
+            list = []
+            member_or_group.each do |m|
+              list << make_member(name, m)
+            end
+            list.compact!
+            if list == []
+              member_or_group = nil
+            elsif list.size == 1
+              member_or_group = list.first
+            else
+              member_or_group = Dub::FunctionGroup.new(self)
+              # set overloaded_index
+              list.each_with_index do |m, i|
+                m.overloaded_index = i + 1
+                member_or_group << m
+              end
+            end
+          end
+        elsif member_or_group.kind_of?(Hpricot::Elem)
+          source[name] = member_or_group = make_member(name, member_or_group)
+        end
+      end
+      member_or_group
+    end
+
+    def make_member(name, member)
+      member = case member[:kind]
+      when 'function', 'slot'
+        Dub.logger.info "Building #{members_prefix}::#{name}"
+        Function.new(self, name, member, members_prefix)
+      when 'class'
+        Dub.logger.info "Building #{members_prefix}::#{name}"
+        Klass.new(self, name, member, members_prefix)
+      else
+        # not supported: ignore
+        return nil
+      end
+
+      ignore_member?(member) ? nil : member
+    end
+
+    def ignore_member?(member)
+      return false if member.kind_of?(Klass)
+
+      if !member.public? ||
+         member.name =~ /^~/           || # do not build constructor
+         member.name =~ /^operator/    || # no conversion operators
+         member.has_complex_arguments? || # no complex arguments or return values
+         member.has_array_arguments? ||
+         member.vararg? ||
+         member.original_signature =~ /void\s+\*/ # used to detect return value and parameters
+        true # ignore
+      elsif return_value = member.return_value
+        if return_value.create_type == 'const char *'
+          return false # do not ignore
+        end
+        return_value.type =~ />$/    || # no complex return types
+        (return_value.is_native? && member.return_value.is_pointer?)
+      else
+        false # ok, do not ignore
+      end
+    end
+  end
+end # Dub

data/lib/dub/namespace.rb

@@ -0,0 +1,295 @@
+require 'dub/member_extraction'
+
+module Dub
+
+  class Namespace
+    @@namespaces = {}
+
+    def self.find(name)
+      @@namespaces[name]
+    end
+
+    include MemberExtraction
+    attr_accessor :name, :gen, :xml, :enums, :parent, :header, :prefix, :defines
+
+    def initialize(name, xml, current_dir)
+      @@namespaces[name] = self
+      @name, @xml, @current_dir = name, xml, current_dir
+      @class_alias = {}
+      @alias_names = []
+      @enums   = []
+      @defines = []
+      @ignores = []
+      parse_xml
+    end
+
+    def bind(generator)
+      self.gen = generator.namespace_generator
+    end
+
+    def gen=(generator)
+      @gen = generator
+      @gen_members = nil
+    end
+
+    def generator
+      @gen
+    end
+
+    def class_generator
+      @gen && @gen.class_generator
+    end
+
+    def function_generator
+      @gen && @gen.function_generator
+    end
+
+    alias gen generator
+
+    def to_s
+      @gen.namespace(self)
+    end
+
+    def merge!(group)
+      raise "Can only merge with a Group" unless group.kind_of?(Group)
+      @defines += group.defines
+      @enums   += group.enums
+
+      # TODO: do we need to merge classes and members ? I don't think so (they should be in namespace).
+    end
+
+    def ignore(list)
+      list = [list].flatten
+      @ignores += list
+      self.classes.reject! {|k| list.include?(k.name) }
+      @ignores.uniq!
+      @gen_members = nil
+    end
+
+    def full_type
+      @parent ? "#{@parent.full_type}::#{name}" : name
+    end
+
+    def lib_name
+      @lib_name || (prefix ? "#{prefix}_#{name}" : name)
+    end
+
+    # FIXME: test
+    def lib_name=(name)
+      @lib_name = name
+    end
+
+    def id_name(name = self.name)
+      prefix ? "#{prefix}.#{name}" : name
+    end
+
+    def header
+      @header ||= (@xml/'location').first.attributes['file'].split('/').last
+    end
+
+    def [](name)
+      get_member(name.to_s) || klass(name.to_s)
+    end
+
+    def function(name)
+      member = get_member(name.to_s)
+      member.kind_of?(Function) ? member : nil
+    end
+
+    def klass(name)
+      get_class(name.to_s, @classes_hash) || get_alias(name.to_s)
+    end
+
+    def template_class(name)
+      get_class(name.to_s, @t_classes_hash)
+    end
+
+    def classes
+      @classes ||= begin
+        list = []
+        @classes_hash.each do |name, member|
+          list << get_class(name, @classes_hash)
+        end
+        list.compact!
+        list.sort
+      end
+    end
+
+    def members
+      list = super(@ignores)
+      if self.generator
+        @gen_members ||= self.generator.members_list(list)
+      else
+        list
+      end
+    end
+
+    def has_constants?
+      has_enums? || has_defines?
+    end
+
+    # FIXME: test
+    def has_functions?
+      members && members != []
+    end
+
+    def has_enums?
+      !@enums.empty?
+    end
+
+    def has_defines?
+      !@defines.empty?
+    end
+
+    def register_alias(name, klass)
+      @class_alias[name] = klass
+    end
+
+    private
+      def parse_xml
+        parse_enums
+        parse_members
+        parse_classes
+      end
+
+      def parse_enums
+        @enums = (@xml/"enumvalue/name").map{|e| e.innerHTML}
+      end
+
+      # We do not run this by default but use groups to make sure we do
+      # not cluter namespace
+      def parse_defines
+        @defines = (@xml/"memberdef[@kind=define]").map do |e|
+          if (e/'param').first
+            nil
+          else
+            (e/'name').innerHTML
+          end
+        end.compact
+      end
+
+      def parse_classes
+        @classes_hash   = {}
+        @t_classes_hash = {}
+        @classes_by_ref = {}
+        (@xml/'innerclass').each do |klass|
+          name = klass.innerHTML
+          Dub.logger.info "Parsing #{name}"
+          if name =~ /^#{@name}::(.+)$/
+            name = $1
+          end
+          filename = klass.attributes['refid']
+          filepath = File.join(@current_dir, "#{filename}.xml")
+          if File.exist?(filepath)
+            class_xml = (Hpricot::XML(File.read(filepath))/'compounddef').first
+            if (class_xml/'/templateparamlist/param').innerHTML != ''
+              @t_classes_hash[name] = class_xml
+            else
+              @classes_hash[name] = class_xml
+            end
+            @classes_by_ref[class_xml[:id]] = class_xml
+          else
+            Dub.logger.warn "Could not open #{filepath}"
+            nil
+          end
+        end
+        parse_template_class_typedefs
+      end
+
+      def parse_template_class_typedefs
+        (@xml/'memberdef[@kind=typedef]').each do |typedef_xml|
+          # <type><ref refid="classdoxy_1_1_t_mat" kindref="compound">TMat</ref>&lt; float &gt;</type>
+          if id = (typedef_xml/'/type/ref').first
+            id = id[:refid]
+          end
+
+          new_name = (typedef_xml/'name').innerHTML
+
+          if ref_class = @classes_by_ref[id]
+            if (typedef_xml/'/type').innerHTML =~ /&gt;$/
+
+              # nested template types, too hard for us, ignore
+              next if (typedef_xml/'/type').innerHTML =~ /&gt;\s+&gt;/
+
+              # template typedef
+              old_name = (ref_class/'/compoundname').first.innerHTML.gsub(/^.*::/,'')
+
+              # replace class name
+              # <type><ref refid="classcv_1_1_scalar__" kindref="compound">Scalar_</ref>&lt; _Tp &gt;</type>
+              class_def = ref_class.to_s.gsub(/<ref .*>#{old_name}<\/ref>&lt;.*?&gt;/, new_name)
+              class_def = class_def.gsub(/#{old_name}/, new_name)
+
+              # replace template types
+              # get template parameters
+              ttypes = (ref_class/'/templateparamlist/param').map do |param|
+                if type = (param/'declname').first
+                  type.innerHTML
+                else
+                  (param/'type').innerHTML.gsub(/^\s*(typename|class)\s+/,'')
+                end
+              end
+
+              types_map = {}
+              instanciations_params = []
+               (typedef_xml/'/type').innerHTML[/&lt;\s*(.+?)\s*&gt;$/,1].split(',').map(&:strip).each_with_index do |type, i|
+                instanciations_params << type
+                types_map[ttypes[i]] = type
+              end
+
+              class_xml = (Hpricot::XML(class_def)/'compounddef').first
+
+              (class_xml/'*[@prot=private]').remove
+              (class_xml/'/templateparamlist').remove
+              (class_xml/'').append("<originaltemplate>#{old_name}</originaltemplate>")
+              (ref_class/'').append("<instanciation><name>#{new_name}</name><param>#{instanciations_params.join('</param><param>')}</param></instanciation>")
+
+              types_map.each do |template_type, real_type|
+                (class_xml/'type').each do |t|
+                  t.swap(t.to_s.gsub(template_type, real_type))
+                end
+              end
+
+              @classes_hash[new_name] = class_xml
+            else
+              # alias
+              original_name = (typedef_xml/'/type/ref').innerHTML
+              if class_xml = @classes_hash[original_name]
+                @alias_names << new_name
+                if (class_xml/'/aliases').first
+                  (class_xml/'/aliases').append("<name>#{new_name}</name>")
+                else
+                  (class_xml/'').append("<aliases><name>#{new_name}</name></aliases>")
+                end
+              else
+                Dub.logger.warn "Could not find original class #{original_name}"
+              end
+            end
+          else
+            Dub.logger.warn "Could not find reference class #{id}"
+          end
+        end
+      end
+
+      def get_class(name, source)
+        if klass = source[name]
+          if klass.kind_of?(Hpricot::Elem)
+            klass = source[name] = make_member(name, klass)
+          end
+        end
+        klass
+      end
+
+      def get_alias(name)
+        if klass = @class_alias[name]
+          return klass
+        elsif @classes || !@alias_names.include?(name)
+          # classes parsed, alias does not exist
+          nil
+        else
+          # we need to parse all classes so they register the alias
+          self.classes
+          @class_alias[name]
+        end
+      end
+  end
+end # Namespace

data/lib/dub/opts_parser.rb

@@ -0,0 +1,30 @@
+module Dub
+  module OptsParser
+    ENTRY_REGEXP = %r{^\s*([^:]+):\s*('[^']*'|"[^"]*")\s*,?\s*}m
+    def self.extract_hash(xml)
+      (xml/'simplesect').each do |x|
+        if (x/'title').inner_html == 'Bindings info:'
+          (x/'title').remove()
+          (x/'ref').each do |r|
+            r.swap(r.inner_html)
+          end
+          code = EntitiesUnescape::Decoder.decode((x/'para').inner_html)
+          return self.parse(code)
+        end
+      end
+      nil
+    end
+
+    def self.parse(src)
+      res = {}
+      while !src.empty? && src =~ ENTRY_REGEXP
+        src = src.sub(ENTRY_REGEXP) do
+          res[$1.to_sym] = $2[1..-2]
+          ''
+        end
+      end
+      res
+    end
+  end # OptsParser
+end # Dub
+

data/lib/dub/parser.rb

@@ -0,0 +1,46 @@
+require 'rubygems'
+require 'hpricot'
+require 'dub/namespace'
+
+module Dub
+  class Parser
+    def initialize(filepath)
+      @current_dir = File.dirname(filepath)
+      @xml = Hpricot::XML(File.read(filepath))
+    end
+
+    def [](name)
+      namespaces[name.to_s] || groups[name.to_s]
+    end
+
+    def namespace(name)
+      namespaces[name.to_s]
+    end
+
+    def group(name)
+      groups[name.to_s]
+    end
+
+    def namespaces
+      @namespaces ||= begin
+        ns = {}
+        (@xml/'compounddef[@kind=namespace]').each do |namespace|
+          name = (namespace/"compoundname").innerHTML
+          ns[name] = Dub::Namespace.new(name, namespace, @current_dir)
+        end
+        ns
+      end
+    end
+
+    def groups
+      @groups ||= begin
+        groups = {}
+        (@xml/'compounddef[@kind=group]').each do |namespace|
+          name = (namespace/"compoundname").innerHTML
+          groups[name] = Dub::Group.new(name, namespace, @current_dir)
+        end
+        groups
+      end
+    end
+  end # Parser
+end

data/lib/dub/templates/lua_template.erb

@@ -0,0 +1,21 @@
+
+static bool is_userdata(lua_State *L, int index, const char *tname) {
+  void *p = lua_touserdata(L, index);
+  if (p != NULL) {  /* value is a userdata? */
+    if (lua_getmetatable(L, index)) {  /* does it have a metatable? */
+      lua_getfield(L, LUA_REGISTRYINDEX, tname);  /* get correct metatable */
+      if (lua_rawequal(L, -1, -2)) {  /* does it have the correct mt? */
+        lua_pop(L, 2);  /* remove both metatables */
+        // type match
+        return true;
+      }
+    }
+  }
+  // type does not match
+  return false;
+}
+
+<%= @bindings %>
+
+<%= @init_code %>
+

data/lib/dub/version.rb

@@ -0,0 +1,3 @@
+module Dub
+  VERSION = '1.0.0'
+end

data/lib/dub.rb

@@ -1,37 +1,27 @@
-# Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+require 'dub/entities_unescape'
+require 'dub/parser'
+require 'dub/namespace'
+require 'dub/group'
+require 'dub/klass'
+require 'dub/function'
+require 'dub/argument'
+require 'logger'
+require 'dub/opts_parser'
 
-# typed: true
-# frozen_string_literal: true
+module Dub
+  def self.logger=(logger)
+    @@logger = logger
+  end
 
-module OpenApiSDK
-  autoload :Dub, 'open_api_sdk/dub'
-  autoload :Links, 'open_api_sdk/links'
-  autoload :Analytics, 'open_api_sdk/analytics'
-  autoload :Events, 'open_api_sdk/events'
-  autoload :Tags, 'open_api_sdk/tags'
-  autoload :Folders, 'open_api_sdk/folders'
-  autoload :Domains, 'open_api_sdk/domains'
-  autoload :Track, 'open_api_sdk/track'
-  autoload :Customers, 'open_api_sdk/customers'
-  autoload :Partners, 'open_api_sdk/partners'
-  autoload :Commissions, 'open_api_sdk/commissions'
-  autoload :Workspaces, 'open_api_sdk/workspaces'
-  autoload :EmbedTokens, 'open_api_sdk/embed_tokens'
-  autoload :QRCodes, 'open_api_sdk/qr_codes'
-  module Models
-    autoload :Shared, 'open_api_sdk/models/shared'
-    autoload :Operations, 'open_api_sdk/models/operations'
-    autoload :Errors, 'open_api_sdk/models/errors'
-    autoload :Callbacks, 'open_api_sdk/models/callbacks'
+  def self.logger
+    @@logger ||= begin
+      logger = Logger.new(STDERR)
+      logger.level == Logger::INFO
+      logger
+    end
   end
-end
 
-require_relative 'open_api_sdk/utils/utils'
-require_relative 'open_api_sdk/utils/request_bodies'
-require_relative 'open_api_sdk/utils/query_params'
-require_relative 'open_api_sdk/utils/forms'
-require_relative 'open_api_sdk/utils/headers'
-require_relative 'open_api_sdk/utils/url'
-require_relative 'open_api_sdk/utils/security'
-require_relative 'crystalline'
-require_relative 'open_api_sdk/sdkconfiguration'
+  def self.parse(filename)
+    Dub::Parser.new(filename)
+  end
+end