dub 0.5.0

data/test/klass_test.rb

@@ -0,0 +1,297 @@
+require 'helper'
+require 'dub/lua'
+
+class KlassTest < Test::Unit::TestCase
+
+  context 'A Klass' do
+    setup do
+      # namespacecv_xml = Dub.parse(fixture('app/xml/namespacedub.xml'))
+      @class = namespacedub_xml[:dub][:Matrix]
+    end
+
+    should 'return a list of Functions with members' do
+      assert_kind_of Array, @class.members
+      assert_kind_of Dub::Function, @class.members.first
+    end
+
+    should 'return name with name' do
+      assert_equal 'Matrix', @class.name
+    end
+
+    should 'have namespace prefix' do
+      assert_equal 'dub', @class.prefix
+    end
+
+    should 'combine prefix and name in lib_name' do
+      assert_equal 'dub_Matrix', @class.lib_name
+    end
+
+    should 'combine prefix and name in id_name' do
+      assert_equal 'dub.Matrix', @class.id_name
+    end
+
+    should 'combine prefix and provided name in id_name' do
+      assert_equal 'dub.Foobar', @class.id_name('Foobar')
+    end
+
+    should 'use parent namespace in full_type' do
+      assert_equal 'dub::Matrix', @class.full_type
+    end
+
+    should 'return file and line on source' do
+      assert_match %r{app/include/matrix\.h:\d+}, @class.source
+    end
+
+    should 'return a list of class methods' do
+      assert_kind_of Array, @class.class_methods
+    end
+
+    context 'bound member list' do
+      setup do
+        Dub::Lua.bind(@class)
+        @list = @class.members.map {|m| m.name}
+      end
+
+      should 'remove destructor from member list' do
+        assert !@list.include?("~Matrix")
+      end
+
+      should 'remove constructor from member list' do
+        assert !@list.include?("Matrix")
+      end
+
+      should 'ignore template methods in member list' do
+        assert !@list.include?("give_me_tea")
+      end
+
+      should 'ignore members with templated arguments' do
+        # at least for now
+        assert !@list.include?("mul")
+        assert_no_match %r{Matrix_mul}, @class.to_s
+      end
+
+      should 'ignore operator methods in member list' do
+        assert !@list.include?("operator size_t")
+      end
+
+      should 'ignore members returning native pointers' do
+        assert !@list.include?("ptr")
+      end
+    end
+
+    should 'return constructor with constructor' do
+      const = @class.constructor
+      assert_kind_of Dub::Function, const.first
+    end
+
+    should 'respond to destructor_name' do
+      assert_equal 'Matrix_destructor', @class.destructor_name
+    end
+
+    should 'respond to tostring_name' do
+      assert_equal 'Matrix__tostring', @class.tostring_name
+    end
+
+    should 'respond to constructor.method_name' do
+      assert_equal 'Matrix_Matrix', @class.constructor.method_name(0)
+    end
+
+    should 'find method with array index' do
+      assert_kind_of Dub::Function, @class[:rows]
+    end
+
+    should 'return header name on header' do
+      assert_equal 'matrix.h', @class.header
+    end
+
+    should 'return defined header if changed' do
+      klass = Dub.parse(fixture('app/xml/namespacedub.xml'))[:dub][:Matrix]
+      klass.header = 'opencv/cv.h'
+      assert_equal 'opencv/cv.h', klass.header
+    end
+
+    should 'know that it is not a template' do
+      assert !@class.template?
+    end
+
+    context 'bound to a generator' do
+      setup do
+        Dub::Lua.bind(@class)
+      end
+
+      should 'bind each member' do
+        assert_equal Dub::Lua.function_generator, @class.members.first.gen
+      end
+
+      should 'register constructor' do
+        assert_match %r{\{\s*\"Matrix\"\s*,\s*Matrix_Matrix\s*\}}, @class.to_s
+      end
+
+      should 'build constructor' do
+        result = @class.to_s
+        assert_match %r{static int Matrix_Matrix1\s*\(}, result
+        assert_match %r{static int Matrix_Matrix2\s*\(}, result
+        assert_match %r{static int Matrix_Matrix\s*\(},  result
+      end
+
+      should 'return new objects in constructors' do
+        @class = namespacecv_xml[:cv][:Mat]
+        Dub::Lua.bind(@class)
+        assert_match %r{lua_pushclass<Mat>.*"cv.Mat"}, @class.constructor.first.to_s
+      end
+
+      should 'include class header' do
+        assert_match %r{#include\s+"matrix.h"}, @class.to_s
+      end
+
+      should 'include helper header' do
+        assert_match %r{#include\s+"lua_cpp_helper.h"}, @class.to_s
+      end
+
+      should 'create Lua metatable with class name' do
+        assert_match %r{luaL_newmetatable\(L,\s*"dub.Matrix"\)}, @class.to_s
+      end
+
+      should 'not build template methods' do
+        assert_no_match %r{give_me_tea}, @class.to_s
+      end
+
+      should 'declare tostring' do
+        assert_match %r{__tostring}, @class.to_s
+      end
+
+      should 'implement tostring' do
+        assert_match %r{Matrix__tostring\(lua_State}, @class.to_s
+      end
+    end
+  end
+
+  context 'A template class' do
+    setup do
+      # namespacecv_xml = Dub.parse(fixture('app/xml/namespacedub.xml'))
+      @class = namespacedub_xml[:dub].template_class(:TMat)
+    end
+
+    should 'know that it is a template' do
+      assert @class.template?
+    end
+
+    should 'return template parameters' do
+      assert_equal ['T'], @class.template_params
+    end
+  end
+
+  context 'A class defined from a template' do
+    setup do
+      @class = namespacecv_xml[:cv][:Size]
+    end
+
+    should 'replace template parameter in method arguments' do
+      Dub::Lua.bind(@class)
+      assert_match %r{int *_width}, @class.to_s
+    end
+
+    should 'register in the template for these types' do
+      @tclass = namespacecv_xml[:cv].template_class(:Size_)
+      assert_equal @class, @tclass.instanciations[['int']]
+    end
+  end
+
+  context 'A class with alias names' do
+    setup do
+      # namespacecv_xml = Dub.parse(fixture('app/xml/namespacedub.xml'))
+      @class = namespacedub_xml[:dub][:FloatMat]
+    end
+
+    should 'return a list of these alias on alias_names' do
+      assert_equal ['FloatMat'], @class.alias_names
+      assert_equal 'FMatrix', @class.name
+    end
+
+    should 'find class from alias in namespace' do
+      assert_equal @class, namespacedub_xml[:dub][:FMatrix]
+    end
+
+    should 'use the shortest alias as main name' do
+      assert_equal 'Size', namespacecv_xml[:cv][:Size2i].name
+    end
+
+    should 'rename constructors to shortest name' do
+      assert_equal 'Size', namespacecv_xml[:cv][:Size].constructor.name
+    end
+
+    should 'parse arguments and evaluate types by resolving template params' do
+      size_class = namespacecv_xml[:cv][:Size]
+      Dub::Lua.bind(size_class)
+      assert_match %r{const Point \*pt}, size_class.constructor[5].to_s
+    end
+
+    context 'bound to a generator' do
+      setup do
+        Dub::Lua.bind(@class)
+      end
+
+      should 'register all alias_names' do
+        result = @class.to_s
+        assert_match %r{"FloatMat"\s*,\s*FMatrix_FMatrix}, result
+        assert_match %r{"FMatrix"\s*,\s*FMatrix_FMatrix}, result
+        assert_match %r{luaL_register\(L,\s*"dub".*FMatrix_namespace_methods}, result
+      end
+
+      should 'use the smallest name in method definition' do
+        assert_match %r{int FMatrix_FMatrix}, @class.to_s
+      end
+    end
+  end
+
+  context 'A class with overloaded methods' do
+    setup do
+      # namespacecv_xml = Dub.parse(fixture('app/xml/namespacedub.xml'))
+      @class = namespacecv_xml[:cv][:Mat]
+      Dub::Lua.bind(@class)
+    end
+
+    should 'declare chooser' do
+      result = @class.gen.method_registration(@class)
+      assert_match %r{"zeros"\s*,\s*Mat_zeros\}}, result
+      assert_no_match %r{zeros1}, result
+    end
+  end
+
+  context 'A complex class' do
+    setup do
+      # namespacecv_xml = Dub.parse(fixture('app/xml/namespacedub.xml'))
+      @class = namespacecv_xml[:cv][:Mat]
+    end
+
+    context 'bound to a generator' do
+      setup do
+        Dub::Lua.bind(@class)
+      end
+
+      should 'list all members on members' do
+        assert_equal %w{addref adjustROI assignTo channels clone col colRange convertTo copyTo create cross depth diag dot elemSize elemSize1 empty eye isContinuous locateROI ones release reshape row rowRange setTo size step1 type zeros}, @class.members.map {|m| m.name}
+      end
+    end
+  end
+
+  context 'A class with enums' do
+    setup do
+      # namespacecv_xml = Dub.parse(fixture('app/xml/namespacedub.xml'))
+      @class = namespacecv_xml[:cv][:Mat]
+    end
+
+    should 'respond true to has_enums' do
+      assert @class.has_constants?
+    end
+
+    should 'produce namespaced declarations' do
+      assert_match %r{\{"AUTO_STEP"\s*,\s*cv::Mat::AUTO_STEP\}}, Dub::Lua.class_generator.constants_registration(@class)
+    end
+
+    should 'find a list of enums' do
+      assert_equal %w{MAGIC_VAL AUTO_STEP CONTINUOUS_FLAG}, @class.enums
+    end
+  end
+
+end

data/test/lua_function_gen_test.rb

@@ -0,0 +1,179 @@
+require 'helper'
+require 'dub/lua'
+
+class LuaFunctionGenTest < Test::Unit::TestCase
+  context 'A Lua generator' do
+    setup do
+      @generator = Dub::Lua
+    end
+
+    context 'with a function' do
+      setup do
+        # namespacecv_xml = Dub.parse(fixture('namespacecv.xml'))
+        @function = namespacecv_xml[:cv][:resize]
+      end
+
+      should 'return Function on bind' do
+        assert_kind_of Dub::Function, @generator.bind(@function)
+      end
+    end
+  end
+
+  context 'A Function' do
+    setup do
+      @function = namespacecv_xml[:cv][:resize]
+    end
+
+    context 'bound to a Lua generator' do
+      setup do
+        Dub::Lua.bind(@function)
+        @generator = Dub::Lua.function_generator
+      end
+
+
+      should 'return string on to_s' do
+        assert_kind_of String, @function.to_s
+      end
+
+      should 'generate a static function returning an int' do
+        assert_match %r{static int cv_resize}, @function.to_s
+      end
+
+      should 'insert code to check for an arguments on get_arg' do
+        assert_match /Mat.*\*\s*src\s*=\s*\*\(\(const\s+Mat\s+\*\*\)\s*luaL_checkudata\s*\(L,\s*1,\s*\"cv\.Mat\"\s*\)\)\s*;/,
+                     @generator.get_arg(@function.arguments.first, 1) # 1 = first argument in Lua stack
+      end
+
+      context 'with default values' do
+        should 'verify stack size' do
+          assert_match /top__\s*<\s*6/, @generator.function(@function)
+        end
+      end
+
+      context 'in a class with a class as parameter' do
+        setup do
+          @function = namespacecv_xml[:cv][:Mat][:locateROI]
+        end
+
+        should 'use parameter class identifier' do
+          assert_match /Size\s*\*\*\)luaL_checkudata\s*\(L,\s*1,\s*\"cv\.Size\"\s*\)\)\s*;/,
+                       @generator.get_arg(@function.arguments.first, 1) # 1 = first argument in Lua stack
+        end
+      end
+    end
+  end
+
+  context 'A group of overloaded functions' do
+    setup do
+      # namespacecv_xml = Dub.parse(fixture('namespacecv.xml'))
+      @function_group = namespacecv_xml[:cv][:divide]
+    end
+
+    context 'bound to a Lua generator' do
+      setup do
+        Dub::Lua.bind(@function_group)
+      end
+
+      should 'return string content on to_s' do
+        assert_kind_of String, @function_group.to_s
+      end
+
+      should 'generate a static function returning an int' do
+        assert_match %r{static int cv_divide}, @function_group.to_s
+      end
+
+      should 'generate a static function returning an int for each overloaded function' do
+        bindings = @function_group.to_s
+        assert_match %r{static int cv_divide1}, bindings
+        assert_match %r{static int cv_divide2}, bindings
+        assert_match %r{static int cv_divide3}, bindings
+        assert_match %r{static int cv_divide4}, bindings
+      end
+
+      # should 'declare chooser' do
+      #   assert_match %r{"divide",\s*cv_divide\}}, @group.to_s
+      # end
+    end
+  end
+
+  context 'A function with a custom class return value' do
+    setup do
+      # namespacecv_xml = Dub.parse(fixture('namespacecv.xml'))
+      @function = namespacecv_xml[:cv][:getRotationMatrix2D]
+    end
+
+    context 'bound to a Lua generator' do
+      setup do
+        Dub::Lua.bind(@function)
+      end
+
+      should 'call template push method' do
+        assert_match %r{lua_pushclass<Mat>\(\s*L\s*,\s*retval__\s*,\s*"cv.Mat"\s*\)}, @function.to_s
+      end
+    end
+  end
+
+  context 'A function with pointer parameters' do
+    setup do
+      # namespacecv_xml = Dub.parse(fixture('namespacecv.xml'))
+      @function = namespacecv_xml[:cv][:calcHist][0]
+    end
+
+    context 'bound to a Lua generator' do
+      setup do
+        Dub::Lua.bind(@function)
+      end
+
+      should 'use a DubArgPointer with the given type' do
+        assert_match %r{DubArgPointer<int>}, @function.to_s
+      end
+    end
+  end
+
+  context 'A member function bound to a Lua generator' do
+    setup do
+      @member = namespacedub_xml[:dub][:Matrix][:rows]
+      Dub::Lua.bind(@member)
+    end
+
+    should 'start by getting self' do
+      assert_match %r{self__\s*=\s*\*\(\(Matrix\*\*\)luaL_checkudata}, @member.to_s
+    end
+
+    should 'prefix call with self' do
+      assert_match %r{self__->rows\(}, @member.to_s
+    end
+  end
+
+  context 'A constructor bound to a Lua generator' do
+    setup do
+      @constructor = namespacedub_xml[:dub][:Matrix][:Matrix].first
+      Dub::Lua.bind(@constructor)
+    end
+
+    should 'use pushclass in constructor' do
+      result = @constructor.to_s
+      assert_match %r{lua_pushclass<Matrix>\s*\(L, retval__, \"dub.Matrix\"\s*\)}, result
+    end
+  end
+
+  context 'A function without return value' do
+    setup do
+      @function = namespacecv_xml[:cv][:blur]
+    end
+
+    context 'bound to a Lua generator' do
+      setup do
+        Dub::Lua.bind(@function)
+      end
+
+      should 'return 0' do
+        assert_match %r{return\s+0}, @function.to_s
+      end
+    end
+  end
+end
+
+
+
+

data/test/namespace_test.rb

@@ -0,0 +1,220 @@
+require 'helper'
+require 'dub/lua'
+
+class NamespaceTest < 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
+
+    should 'remove members on minus equal operator when bound' do
+      namespace = Dub.parse(fixture('app/xml/namespacedub.xml'))[:dub]
+      namespace.ignore 'FMatrix'
+      assert_equal %w{Matrix}, namespace.classes.map{|k| k.name}
+    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
+      setup do
+        @function = namespacecv_xml[:cv][:divide]
+      end
+
+      should 'find a Dub::FunctionGroup' do
+        assert_kind_of Dub::FunctionGroup, @function
+      end
+
+      should 'find a group of functions' do
+        assert_kind_of Dub::Function, @function[0]
+        assert_kind_of Dub::Function, @function[1]
+      end
+
+      should 'group functions by name' do
+        assert_equal 'divide', @function[0].name
+        assert_equal 'divide', @function[1].name
+      end
+
+      should 'assign an overloaded_index to grouped functions' do
+        assert_equal 1, @function[0].overloaded_index
+        assert_equal 2, @function[1].overloaded_index
+      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
+
+    context 'On merge with a group' do
+      setup do
+        @namespace = Dub.parse(fixture('namespacecv.xml'))[:cv]
+        group = Dub.parse(fixture('group___magic_type.xml'))[:MagicType]
+        @namespace.merge!(group)
+        Dub::Lua.bind(@namespace)
+      end
+
+      should 'produce enums and defines 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
+        assert_match %r{\{"CV_32FC1"\s*,\s*CV_32FC1\}}, result
+        assert_match %r{register_constants\(L,\s*"cv",\s*cv_namespace_constants\)}, result
+      end
+    end
+  end
+
+  context 'A Group with defines' do
+    setup do
+      # groupmagic_xml = Dub.parse(fixture('group___magic_type.xml'))
+      @group = groupmagic_xml[:MagicType]
+    end
+
+    should 'parse defines' do
+      assert @group.defines.include?("CV_32FC1")
+    end
+
+    should 'ignore defines with parameters' do
+      assert !@group.defines.include?("CV_8UC")
+    end
+
+    context 'bound to a generator' do
+      setup do
+        Dub::Lua.bind(@group)
+        @group.name = 'cv'
+      end
+
+      should 'produce defines registration' do
+        result = @group.to_s
+        assert_match %r{\{"CV_32FC1"\s*,\s*CV_32FC1\}}, result
+        assert_match %r{register_constants\(L,\s*"cv",\s*cv_namespace_constants\)}, result
+      end
+    end
+  end
+
+  context 'A namespace bound to a generator' do
+    setup do
+      @namespace = namespacecv_xml[:cv]
+      Dub::Lua.bind(@namespace)
+    end
+
+    should 'produce methods registration' do
+      result = @namespace.to_s
+      assert_match %r{\{"resize"\s*,\s*cv_resize\},}, result
+      assert_match %r{luaL_register\(L,\s*"cv".*cv_functions}, result
+    end
+  end
+
+end