dub 0.6.6 → 0.7.0

data/lib/dub/lua/namespace_gen.rb

@@ -49,39 +49,20 @@ module Dub
         res.join(",\n\n")
       end
 
-      def members_list(all_members, ignore_list = [])
-        list = (all_members || []).map do |member_or_group|
-          if ignore_list.include?(member_or_group.name)
-            nil
-          elsif member_or_group.kind_of?(Array)
-            members_list(member_or_group)
-          elsif ignore_member?(member_or_group)
-            nil
-          else
-            member_or_group
-          end
-        end
-
-        list.compact!
-        list == [] ? nil : list
-      end
-
-      def ignore_member?(member)
-        if member.name =~ /^~/           || # do not build constructor
-           member.name =~ /^operator/    || # no conversion operators
-           member.original_signature =~ />/ || # no complex types in signature
-           member.has_array_arguments? ||
-           member.vararg? ||
-           member.original_signature =~ /void\s+\*/ ||
-           member.has_class_pointer_arguments?
-
-          true # ignore
-        elsif return_value = member.return_value
-          return_value.type =~ />$/    || # no complex return types
-          return_value.is_native? && member.return_value.is_pointer?
-        else
-          false # ok, do not ignore
-        end
+      def members_list(all_members)
+        all_members
+        #list = (all_members || []).map do |member_or_group|
+        #  if member_or_group.kind_of?(Array)
+        #    members_list(member_or_group)
+        #  elsif ignore_member?(member_or_group)
+        #    nil
+        #  else
+        #    member_or_group
+        #  end
+        #end
+        #
+        #list.compact!
+        #list == [] ? nil : list
       end
     end
   end

data/lib/dub/member_extraction.rb

@@ -41,10 +41,11 @@ module Dub
       get_member(name.to_s, @members_hash)
     end
 
-    def members
+    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!
@@ -61,12 +62,23 @@ module Dub
       if member_or_group = source[name]
         if member_or_group.kind_of?(Array)
           if member_or_group.first.kind_of?(Hpricot::Elem)
-            list = Dub::FunctionGroup.new(self)
-            member_or_group.each_with_index do |m,i|
-              list << make_member(name, m, i + 1)
+            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
-            member_or_group = list.compact
-            member_or_group = nil if member_or_group == []
           end
         elsif member_or_group.kind_of?(Hpricot::Elem)
           source[name] = member_or_group = make_member(name, member_or_group)
@@ -75,17 +87,41 @@ module Dub
       member_or_group
     end
 
-    def make_member(name, member, overloaded_index = nil)
-      case member[:kind]
-      when 'function'
+    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, overloaded_index)
+        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
-        nil
+        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

data/lib/dub/namespace.rb

@@ -64,7 +64,12 @@ module Dub
     end
 
     def lib_name
-      prefix ? "#{prefix}_#{name}" : name
+      @lib_name || (prefix ? "#{prefix}_#{name}" : name)
+    end
+
+    # FIXME: test
+    def lib_name=(name)
+      @lib_name = name
     end
 
     def id_name(name = self.name)
@@ -104,10 +109,11 @@ module Dub
     end
 
     def members
+      list = super(@ignores)
       if self.generator
-        @gen_members ||= self.generator.members_list(super, @ignores)
+        @gen_members ||= self.generator.members_list(list)
       else
-        super
+        list
       end
     end
 
@@ -115,6 +121,11 @@ module Dub
       has_enums? || has_defines?
     end
 
+    # FIXME: test
+    def has_functions?
+      members && members != []
+    end
+
     def has_enums?
       !@enums.empty?
     end

data/lib/dub/opts_parser.rb

@@ -1,6 +1,6 @@
 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:'
@@ -17,8 +17,8 @@ module Dub
 
     def self.parse(src)
       res = {}
-      while !src.empty?
-        src = src.sub(/^\s*([^:]+):\s*('[^']+'|"[^"]+")\s*,?\s*/m) do
+      while !src.empty? && src =~ ENTRY_REGEXP
+        src = src.sub(ENTRY_REGEXP) do
           res[$1.to_sym] = $2[1..-2]
           ''
         end

data/lib/dub/version.rb

@@ -1,3 +1,3 @@
 module Dub
-  VERSION = '0.6.6'
-end
+  VERSION = '0.7.0'
+end

data/test/argument_test.rb

@@ -160,45 +160,49 @@ class ArgumentTest < Test::Unit::TestCase
   end
 
   context 'A bool argument' do
-    setup do
+    subject do
       # namespacecv_xml = Dub.parse(fixture('namespacecv.xml'))
-      @argument = namespacedub_xml[:dub][:Matrix][:do_something].arguments[1]
+      namespacedub_xml[:dub][:Matrix][:do_something].arguments[1]
+    end
+    
+    should 'belong to the :boolean group' do
+      assert_equal :boolean, Dub::Argument.type_group(MockArgument.new('bool'))
     end
 
     should 'return type with type' do
-      assert_equal 'bool', @argument.type
+      assert_equal 'bool', subject.type
     end
 
     should 'return name with name' do
-      assert_equal 'fast', @argument.name
+      assert_equal 'fast', subject.name
     end
 
     should 'know if argument is const' do
-      assert !@argument.is_const?
+      assert !subject.is_const?
     end
 
     should 'know if argument is passed by ref' do
-      assert !@argument.is_ref?
+      assert !subject.is_ref?
     end
 
     should 'know that it is a pointer' do
-      assert !@argument.is_pointer?
+      assert !subject.is_pointer?
     end
 
     should 'know if argument type is a native type' do
-      assert @argument.is_native?
+      assert subject.is_native?
     end
 
     should 'return bool on create_type' do
-      assert_equal 'bool ', @argument.create_type
+      assert_equal 'bool ', subject.create_type
     end
 
     should 'return signature' do
-      assert_equal 'bool', @argument.signature
+      assert_equal 'bool', subject.signature
     end
 
     should 'return default value if it has one' do
-      assert_equal 'false', @argument.default
+      assert_equal 'false', subject.default
     end
   end
 
@@ -229,7 +233,7 @@ class ArgumentTest < Test::Unit::TestCase
       end
 
       should 'not nest own namespace in type' do
-        assert_match %r{luaL_checkudata\(L,\s*1,\s*\"std\.string\"}, @function.to_s
+        assert_match %r{luaL_checkudata\(L,\s*\d,\s*\"std\.string\"}, @function.to_s
       end
     end
   end
@@ -489,6 +493,36 @@ class ArgumentTest < Test::Unit::TestCase
     end
   end
 
+  context 'A pointer to a const char' do
+    setup do
+      @argument = namespacedub_xml[:dub][:Matrix][:name].return_value
+    end
+
+    should 'belong to the string group' do
+      assert_equal :string, Dub::Argument.type_group(MockArgument.new('char', 'char', true))
+    end
+
+    should 'know if argument is const' do
+      assert @argument.is_const?
+    end
+
+    should 'know if argument is passed by ref' do
+      assert !@argument.is_ref?
+    end
+
+    should 'know that it is a pointer' do
+      assert @argument.is_pointer?
+    end
+
+    should 'return the type without star' do
+      assert_equal 'char', @argument.type
+    end
+
+    should 'create a native type' do
+      assert_equal 'const char *', @argument.create_type
+    end
+  end
+
   context 'In a class defined from a template' do
     setup do
       @class = namespacecv_xml[:cv][:Scalar]

data/test/fixtures/app/include/matrix.h

@@ -6,6 +6,7 @@
 
 
 /** @file */
+typedef int LuaStackSize;
 
 namespace dub {
 
@@ -13,8 +14,12 @@ namespace dub {
  *
  * @dub var_from_dub:'dummy value'
  *      other_from_dub: "some other value"
+ *      ignore: 'bad_method'
  */
 class Matrix {
+
+  Q_PROPERTY(size_t foo_prop READ size)
+  Q_PROPERTY(size_t size READ size WRITE setSize)
 public:
   Matrix() : data_(NULL), rows_(0), cols_(0) {}
 
@@ -58,6 +63,14 @@ public:
 
   }
 
+  void do_something(int i, const char *baz) {
+    // overloaded member method
+  }
+
+  void bad_method(int i) {
+    // method should not exist in bindings
+  }
+
   void use_other_lib(const std::string &name) {
     // dummy
   }
@@ -66,10 +79,24 @@ public:
     // dummy
   }
 
+  bool true() {
+    // dummy
+    return true;
+  }
+
+  const char *name() {
+    // should make method return string
+  }
+
   int *lua_thing(int a, lua_State *L, int b) {
     // dummy
   }
 
+  LuaStackSize work_with_lua(int a, int b) {
+    // method that directly pushes lua values on the stack
+    return 2;
+  }
+
   /** Named constructor.
    */
   static Matrix *MakeMatrix(int rows, int cols) {
@@ -77,6 +104,9 @@ public:
   }
 
 private:
+  Matrix(int x) {
+    // private constructor
+  }
 
   int private_method() {
     // should not be implemented
@@ -96,6 +126,97 @@ protected:
 };
 
 
+/** Test that private constructors are not used.
+ */
+class PrivateConstr {
+public:
+
+  PrivateConstr(int x) {}
+
+  ~PrivateConstr() {}
+
+private:
+  // should not be used to build a FunctionGroup
+  PrivateConstr(const char *name) {}
+};
+
+/** Test that custom destructors are used.
+ * @dub destructor: 'dub_destroy'
+ */
+class CustomDestructor : public DeletableOutOfLua
+{
+public:
+
+  CustomDestructor(int x) {}
+
+  ~CustomDestructor() {}
+
+  void do_this(int x) {
+
+  }
+};
+
+/** Test that no destructor option is used.
+ *
+ * @dub destructor: ''
+ */
+class NoDestructor {
+public:
+
+  NoDestructor(int x) {}
+
+  ~NoDestructor() {}
+};
+
+/** Test that we can use a static constructor.
+ * @dub constructor: 'MakeStaticConstr'
+ */
+class StaticConstr {
+public:
+
+  StaticConstr(int x) {}
+
+  ~StaticConstr() {}
+
+  // We usually want to push the userdata ourself in
+  // such cases.
+  static LuaStackSize MakeStaticConstr(lua_State *L) {
+    return 0; // fake error (nil return)
+  }
+};
+
+// class inheritence tests
+class Base {
+public:
+  Base() {}
+  ~Base() {}
+
+  const char *method_in_base(int x, float y) {
+    return "nothing";
+  }
+};
+
+// class inheritence tests
+class SubBase : public Base {
+public:
+  SubBase() {}
+  ~SubBase() {}
+
+  void method_in_sub(float y) {
+    return "nothing";
+  }
+};
+
+// class inheritence tests
+class PrivSubBase : private Base {
+public:
+  SubBase() {}
+  ~SubBase() {}
+
+  void method_in_sub(float y) {
+    return "nothing";
+  }
+};
 template<class T>
 class TMat {
 public: