dub 0.10.3 → 1.0.0

data/test/function_group_test.rb

@@ -0,0 +1,43 @@
+require 'helper'
+require 'dub/lua'
+
+class FunctionGroupTest < Test::Unit::TestCase
+
+  context 'A FunctionGroup' do
+    should 'keep its members sorted by overloaded_index' do
+      @group = namespacecv_xml[:cv][:divide]
+      assert_equal [1, 2, 3, 4], @group.map {|f| f.overloaded_index}
+      
+      assert_match %r{lua_type\(L, 1\)}, Dub::Lua.function_generator.chooser_body(@group)
+    end
+
+    should 'start getting type on first argument' do
+      @group = namespacecv_xml[:cv][:divide]
+      assert_match %r{lua_type\(L, 1\)}, Dub::Lua.function_generator.chooser_body(@group)
+    end
+    
+    should 'not use top__ in chooser if all methods have same arg count' do
+      @method = namespacecv_xml[:cv][:Mat][:diag]
+      Dub::Lua.bind(@method)
+      assert_no_match %r{top__}, Dub::Lua.function_generator.chooser_body(@method)
+    end
+
+    should 'use top__ in chooser if some methods have different arg count' do
+      @method = namespacecv_xml[:cv][:Mat][:Mat]
+      Dub::Lua.bind(@method)
+      assert_match %r{top__}, Dub::Lua.function_generator.chooser_body(@method)
+    end
+    
+    context 'from overloaded members' do
+      subject do
+        namespacedub_xml[:dub][:Matrix][:do_something]
+      end
+
+      should 'start getting type on second argument' do
+        # Function selector should not be fooled by the first arg == self
+        assert_no_match %r{lua_type\(L, 1\)}, Dub::Lua.function_generator.chooser_body(subject)
+        assert_match %r{lua_type\(L, 2\)}, Dub::Lua.function_generator.chooser_body(subject)
+      end
+    end
+  end
+end

data/test/function_test.rb

@@ -0,0 +1,405 @@
+require 'helper'
+require 'dub/lua'
+
+class FunctionTest < Test::Unit::TestCase
+
+  context 'A Function' do
+    setup do
+      # namespacecv_xml = Dub.parse(fixture('namespacecv.xml'))
+      @function = namespacecv_xml[:cv][:resize]
+    end
+
+    should 'return a list of Arguments with arguments' do
+      assert_kind_of Array, @function.arguments
+      assert_kind_of Dub::Argument, @function.arguments.first
+    end
+
+    should 'return name with name' do
+      assert_equal 'resize', @function.name
+    end
+
+    should 'have namespace prefix' do
+      assert_equal 'cv', @function.prefix
+    end
+
+    should 'use prefix in id_name' do
+      assert_equal 'cv.resize', @function.id_name
+    end
+
+    should 'display original_signature' do
+      assert_equal 'CV_EXPORTS void cv::resize(const Mat &src, Mat &dst, Size dsize, double fx=0, double fy=0, int interpolation=INTER_LINEAR)', @function.original_signature
+    end
+
+    should 'return file and line on source' do
+      assert_equal 'include/opencv/cv.hpp:343', @function.source
+    end
+
+    should 'know if it has default arguments' do
+      assert @function.has_default_arguments?
+    end
+
+    context 'without default arguments' do
+      setup do
+        @function = namespacecv_xml[:cv][:getRotationMatrix2D]
+      end
+
+      should 'know if it has default arguments' do
+        assert !@function.has_default_arguments?
+      end
+    end
+
+    context 'not public' do
+      setup do
+        @function = namespacedub_xml[:dub][:Matrix][:protected_method]
+      end
+
+      should 'not be found' do
+        assert_nil @function
+      end
+    end
+
+    context 'without a return value' do
+      should 'know the type of a returned value' do
+        assert_equal nil, @function.return_value
+      end
+    end
+
+    context 'with a return value' do
+      setup do
+        @function = namespacecv_xml[:cv][:getRotationMatrix2D]
+      end
+
+      should 'return an Argument on return_value' do
+        assert_kind_of Dub::Argument, @function.return_value
+      end
+
+      should 'know the type of a returned value' do
+        assert_equal 'Mat', @function.return_value.type
+      end
+
+      should 'not use a pointer for create_type' do
+        assert_equal 'Mat ', @function.return_value.create_type
+      end
+    end
+
+    context 'with a pointer to native type return value' do
+      setup do
+        @function = namespacecv_xml[:cv][:Mat][:ptr].first
+      end
+
+      should 'know the type of the returned value' do
+        assert_equal 'uchar *', @function.return_value.create_type
+      end
+
+      should 'know that the type is a native pointer' do
+        assert @function.return_value.is_pointer?
+      end
+    end
+
+    context 'with a reference return value' do
+      setup do
+        @function = namespacecv_xml[:cv][:Mat][:adjustROI]
+      end
+
+      should 'strip ref in the create type' do
+        assert_equal 'Mat ', @function.return_value.create_type
+      end
+
+      should 'know that the type is a not native pointer' do
+        assert !@function.return_value.is_pointer?
+      end
+    end
+
+    context 'with a void pointer return value' do
+      setup do
+        @function = namespacecv_xml[:cv][:fastMalloc]
+        #Dub::Lua.bind(@function)
+      end
+
+      should 'strip ref in the create type' do
+        assert_equal 'void *', @function.return_value.create_type
+      end
+
+      should 'be ignored by generator' do
+        assert Dub::Lua.namespace_generator.ignore_member?(@function)
+      end
+    end
+
+    context 'with a class return value' do
+      setup do
+        @function = namespacecv_xml[:cv][:Mat][:row]
+      end
+
+      should 'return new objects in constructors' do
+        Dub::Lua.bind(@function)
+        assert_match %r{lua_pushclass<Mat>.*"cv.Mat"}, @function.to_s
+      end
+    end
+  end
+
+  context 'A vararg method' do
+    setup do
+      @function = namespacecv_xml[:cv][:format]
+    end
+
+    should 'know it is a vararg' do
+      assert @function.vararg?
+    end
+
+    should 'be ignored by generator' do
+      assert Dub::Lua.namespace_generator.ignore_member?(@function)
+    end
+  end
+
+  context 'A constructor with void pointer argument' do
+    setup do
+      @function = namespacecv_xml[:cv][:Mat].constructor[6]
+    end
+
+    should 'be ignored by generator' do
+      assert Dub::Lua.class_generator.ignore_member?(@function)
+    end
+
+    should 'not have array arguments' do
+      assert !namespacecv_xml[:cv][:Mat].constructor[2].has_array_arguments?
+    end
+
+    should 'not be listed in group members if bound' do
+      klass = namespacecv_xml[:cv][:Mat]
+      Dub::Lua.bind(klass)
+      assert !klass.constructor.members.include?(@function)
+    end
+
+    should 'be removed from group list on to_s' do
+      klass = namespacecv_xml[:cv][:Mat]
+      Dub::Lua.bind(klass)
+      assert_no_match %r{void\s*\*_data,\s*size_t}, klass.constructor.to_s
+    end
+  end
+
+  context 'A function with void pointer argument' do
+    setup do
+      @function = namespacecv_xml[:cv][:fastFree]
+    end
+
+    should 'be ignored by generator' do
+      assert Dub::Lua.namespace_generator.ignore_member?(@function)
+    end
+
+    should 'be removed from members list' do
+      Dub::Lua.bind(namespacecv_xml[:cv])
+      assert !namespacecv_xml[:cv].members.include?(@function)
+    end
+  end
+
+  context 'A function with list arguments' do
+    setup do
+      @namespace = namespacecv_xml[:cv]
+      Dub::Lua.bind(@namespace)
+      @group = @namespace[:calcHist]
+      @function = @group[1]
+    end
+
+    # should 'mark argument as list on arg_is_list' do
+    #   @function.arg_is_list(0, 1)
+    #   assert @function.arguments[0].is_list?
+    #   assert !@function.arguments[0].is_list_count?
+    #   assert @function.arguments[1].is_list_count?
+    # end
+
+    should 'respond true to has_class_pointer_arguments' do
+      assert @function.has_class_pointer_arguments?
+    end
+
+    should 'be removed from group list' do
+      assert_nil @group.members
+    end
+
+    should 'remove group from member declaration' do
+      assert_no_match %r{cv_calcHist}, @namespace.gen.functions_registration(@namespace)
+    end
+
+    should 'not be instanciated' do
+      assert_equal '', @group.to_s
+    end
+  end
+
+  context 'A method without arguments' do
+    setup do
+      @function = namespacecv_xml[:cv][:getCPUTickCount]
+    end
+
+    should 'parse return value' do
+      assert_equal 'int64', @function.return_value.type
+    end
+
+    should 'produce a one liner to call function' do
+      Dub::Lua.bind(@function)
+      assert_match %r{int64\s*retval__\s*=\s*getCPUTickCount\(\);}, @function.to_s
+    end
+  end
+
+  context 'A method' do
+    setup do
+      # namespacecv_xml = Dub.parse(fixture('app/xml/namespacedub.xml'))
+      @method = namespacedub_xml[:dub][:Matrix][:size]
+    end
+
+    should 'know that it belongs to a class' do
+      assert @method.member_method?
+    end
+
+    should 'know if it is a constructor' do
+      assert !@method.constructor?
+    end
+
+    should 'return klass on klass' do
+      assert_kind_of Dub::Klass, @method.klass
+    end
+
+    should 'use class id_name in id_name' do
+      assert_equal 'dub.Matrix.size', @method.id_name
+    end
+  end
+
+  context 'A constructor' do
+    setup do
+      @method = namespacedub_xml[:dub][:Matrix][:Matrix].first
+    end
+
+    should 'know that it belongs to a class' do
+      assert @method.member_method?
+    end
+
+    should 'know if it is a constructor' do
+      assert @method.constructor?
+    end
+
+    should 'return class name on return_value create_type' do
+      assert_equal 'Matrix', @method.return_value.type
+    end
+
+    should 'return class name pointer on return_value create_type' do
+      assert_equal 'Matrix *', @method.return_value.create_type
+    end
+
+    context 'from a typedef bound to a generator' do
+      setup do
+        @method = namespacecv_xml[:cv][:Size].constructor.first
+        Dub::Lua.bind(@method)
+      end
+
+      should 'know that it is a constructor' do
+        assert @method.constructor?
+      end
+
+      should 'push new userdata on new' do
+        assert_match %r{lua_pushclass<Size>.*"cv.Size".*return 1}m, @method.generator.return_value(@method)
+      end
+    end
+  end
+
+  context 'A static method in a class' do
+    setup do
+      @method = namespacedub_xml[:dub][:Matrix][:MakeMatrix]
+    end
+
+    should 'know it is static' do
+      assert @method.static?
+    end
+
+    should 'append class in call_name' do
+      assert_equal 'Matrix::MakeMatrix', @method.call_name
+    end
+
+    should 'parse return type' do
+      assert_equal 'Matrix', @method.return_value.type
+    end
+
+    context 'bound to a generator' do
+      setup do
+        Dub::Lua.bind(@method)
+      end
+
+      should 'not try to find self' do
+        assert_no_match %r{self__}, @method.to_s
+      end
+
+      should 'insert the function into the namespace' do
+        @class = namespacedub_xml[:dub][:Matrix]
+        Dub::Lua.bind(@class)
+        result = @class.to_s
+        member_methods_registration = result[/Matrix_member_methods([^;]*);/,1]
+        namespace_methods_registration = result[/Matrix_namespace_methods([^;]*);/,1]
+        assert_no_match %r{Matrix_MakeMatrix}, member_methods_registration
+        assert_match %r{Matrix_MakeMatrix.*Matrix_MakeMatrix}, namespace_methods_registration
+      end
+
+      should 'use class name in call' do
+        assert_match %r{Matrix::MakeMatrix\(}, @method.gen.call_string(@method)
+      end
+    end
+  end
+
+  # This is something like template<typename T2> foo() inside a templated class
+  context 'A template method' do
+    setup do
+      @class = namespacecv_xml[:cv][:Scalar]
+      @method = @class.template_method(:convertTo)
+    end
+
+    should 'know it is a template' do
+      assert @method.template?
+    end
+
+    context 'bound to a generator' do
+      setup do
+        Dub::Lua.bind(@class)
+      end
+
+      should 'be ignored in class members' do
+        assert !@class.members.include?(@method)
+      end
+    end
+  end
+
+  context 'A method in a class defined from a template' do
+    setup do
+      @class = namespacecv_xml[:cv][:Scalar]
+      @method = @class[:all]
+    end
+
+    should 'resolve its arguments' do
+      assert_equal 'double', @method.arguments[0].type
+      assert_equal 'Scalar', @method.return_value.type
+    end
+
+    should 'not be seen as a template' do
+      assert !@method.template?
+    end
+
+    should 'not be seen as having complex types' do
+      assert !@method.has_complex_arguments?
+    end
+
+    context 'bound to a generator' do
+      setup do
+        Dub::Lua.bind(@class)
+      end
+
+      should 'not be ignored in class members' do
+        assert @class.members.include?(@method)
+      end
+    end
+  end
+
+  context 'A method in a class with templated arguments' do
+    setup do
+      @method = namespacedub_xml[:dub][:Matrix][:mul]
+    end
+
+    should 'respond true to has_complex_arguments' do
+      assert @method.has_complex_arguments?
+    end
+  end
+end

data/test/group_test.rb

@@ -0,0 +1,241 @@
+require 'helper'
+require 'dub/lua'
+
+class GroupTest < Test::Unit::TestCase
+  context 'A Namespace' do
+    setup do
+      # namespacecv_xml = Dub.parse(fixture('namespacecv.xml'))
+      @namespace = namespacecv_xml[:cv]
+    end
+
+    should 'find a function with functions method' do
+      assert_kind_of Dub::Function, @namespace.function(:resize)
+    end
+
+    should 'find a function with array index' do
+      assert_kind_of Dub::Function, @namespace[:resize]
+    end
+
+    should 'respond to name' do
+      assert_equal 'cv', @namespace.name
+    end
+
+    should 'respond to lib_name' do
+      # nested namespace could be cv_more
+      assert_equal 'cv', @namespace.lib_name
+    end
+
+    should 'respond to id_name' do
+      # nested namespace could be cv.more
+      assert_equal 'cv', @namespace.id_name
+    end
+
+    should 'return header name on header' do
+      assert_equal 'cv.hpp', @namespace.header
+    end
+
+    should 'return defined header if changed' do
+      namespace = Dub.parse(fixture('namespacecv.xml'))[:cv]
+      namespace.header = 'opencv/cv.h'
+      assert_equal 'opencv/cv.h', namespace.header
+    end
+
+    context 'when bound' do
+      setup do
+        @generator = Dub::Lua.namespace_generator
+      end
+
+      should 'contain generator' do
+        res = Dub::Lua.bind(@namespace)
+        assert_equal res, @namespace
+        assert_equal @generator, @namespace.gen
+      end
+
+    end
+
+    context 'with overloaded functions' do
+      subject do
+        namespacecv_xml[:cv][:divide]
+      end
+
+      should 'find a Dub::FunctionGroup' do
+        assert_kind_of Dub::FunctionGroup, subject
+      end
+
+      should 'find a group of functions' do
+        assert_kind_of Dub::Function, subject[0]
+        assert_kind_of Dub::Function, subject[1]
+      end
+
+      should 'group functions by name' do
+        assert_equal 'divide', subject[0].name
+        assert_equal 'divide', subject[1].name
+      end
+
+      should 'assign an overloaded_index to grouped functions' do
+        assert_equal 1, subject[0].overloaded_index
+        assert_equal 2, subject[1].overloaded_index
+      end
+
+      should 'build chooser body' do
+        Dub::Lua.bind(subject)
+        assert_match %r{cv_divide1.*cv_divide2.*cv_divide3.*cv_divide\(}m, subject.to_s
+      end
+    end
+
+    context 'with overloaded members' do
+      subject do
+        namespacedub_xml[:dub][:Matrix][:do_something]
+      end
+
+      should 'find a Dub::FunctionGroup' do
+        assert_kind_of Dub::FunctionGroup, subject
+      end
+
+      should 'find a group of functions' do
+        assert_kind_of Dub::Function, subject[0]
+        assert_kind_of Dub::Function, subject[1]
+      end
+
+      should 'group functions by name' do
+        assert_equal 'do_something', subject[0].name
+        assert_equal 'do_something', subject[1].name
+      end
+
+      should 'assign an overloaded_index to grouped functions' do
+        assert_equal 1, subject[0].overloaded_index
+        assert_equal 2, subject[1].overloaded_index
+      end
+
+      should 'build chooser body' do
+        Dub::Lua.bind(subject)
+        assert_match %r{Matrix_do_something1.*Matrix_do_something2.*Matrix_do_something\(}m, subject.to_s
+      end
+    end
+
+    context 'with overloaded constructors' do
+      subject do
+        namespacedub_xml[:dub][:Matrix][:Matrix]
+      end
+
+      should 'find a Dub::FunctionGroup' do
+        assert_kind_of Dub::FunctionGroup, subject
+      end
+
+      should 'find a group of functions' do
+        assert_kind_of Dub::Function, subject[0]
+        assert_kind_of Dub::Function, subject[1]
+      end
+
+      should 'group functions by name' do
+        assert_equal 'Matrix', subject[0].name
+        assert_equal 'Matrix', subject[1].name
+      end
+
+      should 'assign an overloaded_index to grouped functions' do
+        assert_equal 1, subject[0].overloaded_index
+        assert_equal 2, subject[1].overloaded_index
+      end
+
+      should 'build chooser body' do
+        Dub::Lua.bind(subject)
+        assert_match %r{Matrix_Matrix1.*Matrix_Matrix2.*Matrix_Matrix\(}m, subject.to_s
+      end
+      
+      should 'choose without self delta index' do
+        Dub::Lua.bind(subject)
+        assert_match %r{top__ < 1}m, subject.generator.chooser_body(subject)
+      end
+    end
+
+    context 'with overloaded containing private members' do
+      subject do
+        namespacedub_xml[:dub][:PrivateConstr][:PrivateConstr]
+      end
+
+      should 'find a Dub::Function' do
+        assert_kind_of Dub::Function, subject
+      end
+
+      should 'not set overloaded_index' do
+        assert_nil subject.overloaded_index
+        Dub::Lua.bind(subject)
+        assert_no_match %r{PrivateConstr_PrivateConstr1}, subject.to_s
+      end
+    end
+  end
+
+  context 'A namespace with class definitions' do
+    setup do
+      @namespace = namespacedub_xml[:dub]
+    end
+
+    should 'find classes by array index' do
+      assert_kind_of Dub::Klass, @namespace[:Matrix]
+    end
+
+    should 'find classes with klass' do
+      assert_kind_of Dub::Klass, @namespace.klass('Matrix')
+    end
+
+    should 'return a list of classes with classes' do
+      assert_kind_of Array, @namespace.classes
+      assert_kind_of Dub::Klass, @namespace.classes.first
+    end
+  end
+
+  context 'A namespace with template class definitions' do
+    setup do
+      @namespace = namespacedub_xml[:dub]
+    end
+
+    should 'ignore template classes in class list' do
+      assert !@namespace.classes.map{|m| m.name}.include?("TMat")
+    end
+
+    should 'return template class with template_class' do
+      assert_kind_of Dub::Klass, @namespace.template_class('TMat')
+    end
+
+    should 'build a full classes for template typedefs' do
+      assert_kind_of Dub::Klass, @namespace.klass(:FloatMat)
+    end
+
+    context 'bound to a generator' do
+      setup do
+        Dub::Lua.bind(@namespace)
+      end
+
+      should 'generate a valid class' do
+        # TODO: rerun all tests for lua class generation
+        assert_match %r{luaL_register\(L,\s*"dub".*FMatrix}, @namespace[:FloatMat].to_s
+      end
+    end
+  end
+
+  context 'A namespace with enums' do
+    setup do
+      @namespace = namespacecv_xml[:cv]
+    end
+
+    should 'respond true to has_enums' do
+      assert @namespace.has_constants?
+    end
+
+    should 'produce namespaced declarations' do
+      assert_match %r{\{"INTER_LINEAR"\s*,\s*cv::INTER_LINEAR\}}, Dub::Lua.namespace_generator.constants_registration(@namespace)
+    end
+
+    context 'bound to a generator' do
+      setup do
+        Dub::Lua.bind(@namespace)
+      end
+
+      should 'produce enums registration' do
+        result = @namespace.to_s
+        assert_match %r{\{"INTER_LINEAR"\s*,\s*cv::INTER_LINEAR\}}, result
+        assert_match %r{register_constants\(L,\s*"cv",\s*cv_namespace_constants\)}, result
+      end
+    end
+  end
+end