easy-swig 1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MDNkNmY2ZmU4YTlkM2Y1YTFmYTA0ZWE2NTc3MmE3NWQ0ZjRhMmE5Yg==
+  data.tar.gz: !binary |-
+    ODE0YmIxYTM1MGU5NTU1YzQ5ZjcwMzliMDBkNjk5ZDY3ZjA5ZmQ5OQ==
+SHA512:
+  metadata.gz: !binary |-
+    M2E2NDljMzMxZThlZWQ1YzdkYTE5OGJjZGExOTE0ODMxOTc0MjU3Mjc3NTdl
+    MGRmZDE2N2UyY2E5OTM5OWMxNzYwYzU3OWE5YmFkZTliYTE0ZTE4YzIyNmRi
+    N2QyMTQ2NGEwZDU1OGIxOWZlMTExMmJlMDFmZjA5YmVkYmRlMDM=
+  data.tar.gz: !binary |-
+    OWQwZWQ2MTVmZTFhMWJhNDZmY2NiYzdlY2NhNDBhN2VkYzU0MzMzMWI1ZmJk
+    OGJiODFjMzIwOWI2NTE4YjZmMGY1NTliNWVlZTBkZDAyMTNlZDMzNWMzNjIy
+    MTQ1YjUzZDU2YWNjNzY0NDBmOGZhZTBmOTRhODA5MzUzOGE0MjE=

data/MIT_LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2013 David Fuenmayor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,86 @@
+EasySwig
+=========
+
+Automatically generates wrappers for C/C++ code using SWIG.
+
+This is both a Ruby Gem and a CLI Tool. Feed it with a directory containing the library's header files (the ones you want to wrap) and a CSV File with basic configuration (see usage). EasySwig will generate the corresponding SWIG interface files (.i) in an output directory. EasySwig also offers a facade allowing you to directly call SWIG in order to generate wrappers in the target language.
+
+EasySwig supports currently only C#. There is  ongoing work on other languages support.
+
+
+Installation and Use
+------------
+
+EasySwig relies on the Doxyparser gem (https://github.com/davfuenmayor/ruby-doxygen-parser) which on his part depends on Nokogiri (http://nokogiri.org) and Doxygen (www.doxygen.org). Refer to Doxyparser for more information.
+
+To actually generate wrappers you may also want to install SWIG (http://www.swig.org/). Currently only SWIG version 2.0.11 is supported. There is  ongoing work on 3.0.0 version support.
+
+
+For using EasySwig you need to create a folder with the following structure:
+(it is recommended to use the subfolder 'spec/Example' as a template)
+
+- A subfolder named 'include' with the header files you want to wrap.
+- A CSV file named 'api.csv' with the name of the namespace you want to wrap and which classes to wrap/ignore.
+- An optional file (optionally named custom_config.i) with %include statements for those header files found in subdirectories (otherwise SWIG won't find them)
+
+There are three operations you can do with EasySwig: 'doxygen', 'generate' and 'swig'
+1. doxygen: Generate Doxygen XML intermediate representation. Here you need the Doxyparser gem installed on your system.
+2. generate: Generate SWIG Interface Files (.i) from the previously generated Doxygen XML intermediate representation
+3. swig: Generate wrappers from your header files and the previously generated .i files. Here you need SWIG installed on your system.
+
+
+As Ruby Gem
+-----------
+
+```shell
+gem install doxyparser
+```
+or add the following line to your Gemfile:
+
+```ruby
+gem 'doxyparser'
+```
+and run `bundle install` from your shell.
+
+Call EasySwig from your Ruby code using default values:
+
+```ruby
+	# Will use as target directory your current working directory (be careful!)
+	EasySwig::doxygen	
+	EasySwig::generate
+	EasySwig::swig
+```
+Or with some configuration:
+
+```ruby
+	config = EasySwig::Config.new('path/to/your/directory')
+	config.stl_support = nil		# Inactivate default support for the STL Library
+	config.html = true				# Generates HTML documentation for your header files
+	EasySwig::doxygen(config)
+	EasySwig::generate(config)
+	config.includes_dir = '/usr/lib/gcc/i686-linux-gnu/4.6.3/include' # Add other system include files you want SWIG to import during wrapper generation
+	EasySwig::swig(config)
+```
+
+You can consult the documentation (generated with YARD) in doc/ subfolder for more information about the EasySwig::Config class and its default values.
+
+
+As CLI
+----------
+
+Download (or clone) this repository. An illustrative example of how to use EasySwig as CLI-Tool is found in subfolder spec/Example.
+Open the corresponding README file and follow the instructions. This Example project can also be used as template for your own wrappers.
+
+```shell
+cd spec/Example
+# Displays command help. Useful for parameter syntax, options and default values
+sh ../../bin/easyswig.sh -h
+# Generate Doxygen XML Intermediate representation. Found in generated subfolder: 'easy-swig/doxygen'
+sh ../../bin/easyswig.sh doxygen
+# Generate SWIG Interface Files (.i). Found in generated subfolder: 'easy-swig/generate'
+sh ../../bin/easyswig.sh generate
+# Generate Wrappers using your installed version of SWIG. Found in generated subfolder: 'easy-swig/swig'
+sh ../../bin/easyswig.sh swig
+```
+
+

data/lib/apinodes/api_attribute.rb

@@ -0,0 +1,6 @@
+module EasySwig
+  class ApiAttribute < ApiVariable
+    attr_accessor :match_static
+    
+  end
+end

data/lib/apinodes/api_class.rb

@@ -0,0 +1,207 @@
+module EasySwig
+
+  class ApiClass < ApiNode
+
+    attr_accessor :api_methods
+    attr_accessor :api_attributes
+    attr_accessor :api_innerclasses
+    attr_accessor :api_enums
+    attr_accessor :ignored_methods
+    attr_accessor :ignored_attributes
+    attr_accessor :ignored_innerclasses
+    attr_accessor :ignored_enums
+    attr_accessor :match_subclasses
+    attr_accessor :match_superclasses
+    attr_accessor :group
+    attr_accessor :wrap_innerclasses
+    attr_accessor :wrap_methods
+    attr_accessor :wrap_enums
+    attr_accessor :wrap_attributes
+    attr_accessor :nested_support
+    attr_accessor :friend_support
+
+    def initialize(hash)
+      super(hash)
+      @lookup_cache = {}
+      @api_methods=[]
+      @api_attributes=[]
+      @api_innerclasses=[]
+      @api_enums=[]
+      @ignored_methods=[]
+      @ignored_attributes=[]
+      @ignored_innerclasses=[]
+      @ignored_enums=[]
+      @director=false
+    end
+
+    def api_nodes
+      [self]
+    end
+    
+    def file
+      return wrapped_node.file if node_type != 'innerclass'
+      return parent.file
+    end
+
+    def assoc_with_node(clazz)
+      super(clazz)
+      assoc_methods
+      assoc_attributes
+      assoc_innerclasses
+      assoc_enums
+    end
+
+    def assoc_methods
+    	all_methods = @wrapped_node.methods + @wrapped_node.methods('public', 'static', nil)
+    	all_methods.reject!{ |f| f.basename == f.basename.upcase }
+    	ign_methods = @ignored_methods.map{|i| i.basename}
+      if @wrap_methods
+        all_methods.each { |m|
+          if not ign_methods.include?(m.basename)
+            hash = {'features' => @features, 'node_type' => 'method', 'parent' => self, 'basename' => m.basename }
+            @api_methods << ApiMethod.new(hash).assoc_with_node(m)
+          end
+        }
+      else
+        assoc_functions(all_methods, @api_methods, @ignored_methods)
+      end
+    end
+
+    def assoc_attributes
+    	all_attributes = @wrapped_node.attributes + @wrapped_node.attributes('public', 'static')
+      ign_attributes = @ignored_attributes.map{|i| i.basename}
+      if @wrap_attributes
+        all_attributes.each { |a|
+          if not ign_attributes.include?(a.basename)
+            hash = {'features' => @features, 'node_type' => 'attribute', 'parent' => self, 'basename' => a.basename }
+            @api_attributes << ApiAttribute.new(hash).assoc_with_node(a)
+          end
+        }
+      else
+        assoc_members(all_attributes, @api_attributes, @ignored_attributes)
+      end
+    end
+
+    def assoc_innerclasses
+    	all_innerclasses = @wrapped_node.innerclasses
+      ign_innerclasses = @ignored_innerclasses.map{|i| i.basename}
+      if @wrap_innerclasses
+        all_innerclasses.each { |c|
+          if !ign_innerclasses.include?(c.basename)
+            hash = {'wrap_methods' => 'x',
+              'wrap_attributes' => 'x',
+              'wrap_enums' => 'x',
+              'wrap_innerclasses' => 'x',
+              'node_type' => 'innerclass',
+              'nested_support' => @nested_support,
+              'features' => @features,
+              'parent' => self,
+              'basename' => c.basename }
+            @api_innerclasses << ApiClass.new(hash).assoc_with_node(c)
+          end
+        }
+      else
+        assoc_members(all_innerclasses, @api_innerclasses, @ignored_innerclasses)
+      end
+    end
+
+    def assoc_enums
+    	all_enums = @wrapped_node.enums
+      ign_enums = @ignored_enums.map{ |i| i.basename }
+      if @wrap_enums
+        all_enums.each { |e|
+          if !ign_enums.include?(e.basename)
+            hash = {'features' => @features, 'node_type' => 'enum', 'parent' => self, 'basename' => e.basename }
+            @api_enums << ApiEnum.new(hash).assoc_with_node(e)
+          end
+        }
+      else
+        assoc_members(all_enums, @api_enums, @ignored_enums)
+      end
+      self
+    end
+    
+    def lookup_node(type)
+    	cached = @lookup_cache[type.escaped_name]
+    	return cached if cached
+    	looked_up = _lookup_node(type)
+    	@lookup_cache[type.escaped_name] = looked_up
+			looked_up
+    end
+    
+    def _lookup_node(type) # TODO use lookup methods of Doxyparser and avoid selects
+    	return Doxyparser::Type.new({ name: type.basename, dir: ""}) if is_primitive?(type.basename) 
+    	return type if is_std?(type.basename)
+    	return @wrapped_node if type.basename == @basename
+    	expanded_type = expand_typedefs(type)
+    	if expanded_type != type
+    		looked_up_type = lookup_node(expanded_type)
+    		return expanded_type if looked_up_type.nil? # TODO why?
+    		looked_up = expanded_type.name.gsub(expanded_type.escaped_name, looked_up_type.escaped_name)
+   			return Doxyparser::Type.new({ name: looked_up, dir: ""})
+   		end
+    	innerclass = innerclasses.select { |ic| ic.basename == type.basename }
+    	unless innerclass.empty?
+    		if type.template?
+    			new_name = type.escaped_name.gsub(type.basename, innerclass[0].name)
+	    		return Doxyparser::Type.new({ name: new_name, dir: innerclass[0].dir})
+    		end
+    		return innerclass[0]
+    	end
+    	enum = enums.select { |ie| ie.basename == type.basename }
+    	return enum[0] unless enum.empty?
+    	if node_type == 'innerclass'
+    		sibling = parent.innerclasses.select { |c| c.basename == type.basename }
+    	else
+    		siblings = parent.classes + parent.structs
+    		sibling = siblings.select { |c| c.basename == type.basename }
+    	end
+    	unless sibling.empty?
+    		if type.template?
+    			new_name = type.escaped_name.gsub(type.basename, sibling[0].name)
+	    		return Doxyparser::Type.new({ name: new_name, dir: sibling[0].dir})
+    		end
+    		return sibling[0] 
+    	end
+    	parent_enum = parent.enums.select { |e| e.basename == type.basename }
+    	return parent_enum[0] unless parent_enum.empty?
+    	if node_type == 'innerclass'
+    		return parent.lookup_node(type)
+    	else
+      	puts "Type '" + type.basename+ "' not found in class '" + @wrapped_node.name + "'\n-> Function or variable will be ignored."
+      	return nil
+    	end
+    end
+    
+    def expand_typedefs(type)
+    	typedef = visible_typedefs.select { |t| t.basename == type.basename } # TODO use Doxyparser, avoid selects
+    	return type if typedef.empty?
+    	new_type = typedef[0].type.dup
+    	new_type.name = type.name.gsub(type.escaped_name, new_type.name)
+    	expand_typedefs(new_type)
+    end
+
+    def visible_typedefs
+    	if node_type == 'innerclass'
+    		return typedefs(:all) 
+    	end    		
+      namespace = @parent
+      files_included = file.files_included
+      ns_typedefs = [] if namespace.nil?
+      ns_typedefs ||= namespace.typedefs.select { |typedef|
+        included_in_files(typedef, [file, *files_included])
+      }
+      typedefs(:all) + file.typedefs + ns_typedefs
+    end
+
+    def included_in_files(typedef, files) ## TODO Optimize this
+      files.any? { |file|
+        ::File.basename(typedef.location) =~ %r{#{file.basename}:\d+$}
+      }
+    end
+    
+    def is_enum_or_innerclass?(target_name)    	
+    	(innerclasses + enums).any?{ |c| c.basename == target_name}
+    end
+  end
+end

data/lib/apinodes/api_enum.rb

@@ -0,0 +1,10 @@
+module EasySwig
+
+  class ApiEnum < ApiNode
+
+    def api_nodes
+      self
+    end
+
+  end
+end

data/lib/apinodes/api_function.rb

@@ -0,0 +1,13 @@
+module EasySwig
+
+  class ApiFunction < ApiNode
+    attr_accessor :match_signature
+    attr_accessor :match_type
+
+    def api_nodes
+      self
+    end
+
+  end
+
+end

data/lib/apinodes/api_group.rb

@@ -0,0 +1,13 @@
+module EasySwig
+
+  class ApiGroup < ApiNode
+
+    attr_accessor :wrap_classes
+    attr_accessor :wrap_functions
+    attr_accessor :wrap_enums
+    attr_accessor :wrap_variables
+    attr_accessor :nested_support
+    attr_accessor :friend_support
+
+  end
+end

data/lib/apinodes/api_method.rb

@@ -0,0 +1,12 @@
+module EasySwig
+
+  class ApiMethod < ApiFunction
+    attr_accessor :match_constructor
+    attr_accessor :match_static
+
+    def constructor?
+      @target_name==parent.target_name
+    end
+
+  end
+end

data/lib/apinodes/api_namespace.rb

@@ -0,0 +1,104 @@
+module EasySwig
+
+	class ApiNamespace < ApiNode
+
+		attr_accessor :api_classes
+		attr_accessor :api_variables
+		attr_accessor :api_functions
+		attr_accessor :api_enums
+		attr_accessor :ignored_functions
+		attr_accessor :ignored_variables
+		attr_accessor :ignored_classes
+		attr_accessor :ignored_enums
+		attr_accessor :wrap_classes
+		attr_accessor :wrap_functions
+		attr_accessor :wrap_enums
+		attr_accessor :wrap_variables
+		attr_accessor :nested_support
+		attr_accessor :friend_support
+
+		def initialize(hash)
+			super(hash)
+			@api_classes=[]
+			@api_variables=[]
+			@api_functions=[]
+			@api_enums=[]
+			@ignored_functions=[]
+			@ignored_variables=[]
+			@ignored_classes=[]
+			@ignored_enums=[]
+		end
+
+		def api_nodes
+			return [self] if @api_classes.empty? # Only if there are no classes in this namespace
+			@api_classes
+		end
+
+		def assoc_with_node(ns)
+			super(ns)
+			all_functions = ns.functions
+			all_functions.reject!{ |f| f.basename == f.basename.upcase }
+			all_classes = ns.classes + ns.structs
+			all_enums = ns.enums
+			all_variables = ns.variables
+			ign_functions = @ignored_functions.map{|i| i.basename}
+			ign_classes = @ignored_classes.map{|i| i.basename}
+			ign_enums = @ignored_enums.map{|i| i.basename}
+			ign_variables = @ignored_variables.map{|i| i.basename}
+
+			if @wrap_functions
+				all_functions.each { |f|
+					if not ign_functions.include?(f.basename)
+						hash = {'features' => @features, 'node_type' => 'function', 'parent' => self, 'basename' => f.basename }
+						@api_functions << ApiFunction.new(hash).assoc_with_node(f)
+					end
+				}
+			else
+				assoc_functions(all_functions, @api_functions, @ignored_functions)
+			end
+
+			if @wrap_classes
+				all_classes.each { |c|
+					if not ign_classes.include?(c.basename)
+						hash = {'wrap_methods' => 'x',
+							'wrap_attributes' => 'x',
+							'wrap_enums' => 'x',
+							'wrap_innerclasses' => 'x',
+							'node_type' => 'class',
+							'nested_support' => @nested_support,
+							'friend_support' => @friend_support,
+							'features' => @features,
+							'parent' => self,
+							'basename' => c.basename }
+						@api_classes << ApiClass.new(hash).assoc_with_node(c)
+					end
+				}
+			else
+				assoc_members(all_classes, @api_classes, @ignored_classes)
+			end
+			
+			if @wrap_variables
+				all_variables.each { |v|
+					if not ign_variables.include?(v.basename)
+						hash = {'features' => @features, 'node_type' => 'variable', 'parent' => self, 'basename' => v.basename}
+						@api_variables << ApiVariable.new(hash).assoc_with_node(v)
+					end
+				}
+			else
+				assoc_members(all_variables, @api_variables, @ignored_variables)
+			end
+			if @wrap_enums
+				all_enums.each { |e|
+					if not ign_enums.include?(e.basename)
+						hash = {'features' => @features, 'node_type' => 'enum', 'parent' => self, 'basename' => e.basename }
+						@api_enums << ApiEnum.new(hash).assoc_with_node(e)
+					end
+				}
+			else
+				assoc_members(all_enums, @api_enums, @ignored_enums)
+			end
+			self
+		end
+
+	end
+end