easy-swig 1.0

data/lib/apinodes/api_node.rb

@@ -0,0 +1,109 @@
+module EasySwig
+
+  class ApiNode
+  	include Util
+  	
+    attr_accessor :basename
+    attr_accessor :target_name
+    attr_accessor :directory
+    attr_accessor :parent
+    attr_accessor :header_file
+    attr_reader :wrapped_node
+    attr_accessor :node_type
+    attr_accessor :match
+    attr_accessor :features
+    attr_accessor :ignore
+    
+    # Redirects calls to lang_settings before completely initialized and to
+    # wrapper_node afterwards
+    def method_missing sym, *args
+      if @wrapped_node.nil?
+      @features.send sym, *args
+      else
+      @wrapped_node.send sym, *args
+      end
+    end
+
+    def to_str
+      if @fullname==nil
+        @fullname=fullname
+      end
+      @node_type+"::"+@fullname
+    end
+
+    def fullname
+      if @parent == nil
+      return @basename
+      else
+        return @parent.fullname+"::"+@basename
+      end
+    end
+
+    def initialize(hash)
+      hash.each_key { |k|
+        send(k.to_s+"=", hash[k]) # TODO features must always come first in the
+        # hash
+      }
+      @basename || @features.infer_native_name(self) unless @target_name.nil?
+      self
+    end
+
+    def assoc_with_node(node)
+      @wrapped_node = node
+      EasySwig::Logger.log %Q{Associating target #{@node_type}: #{@target_name} with native node: #{name}}
+      @basename = node.basename
+      @target_name || @features.infer_target_name(self)
+      self
+    end
+
+    def assoc_functions(all_functions, api_functions, ignored_functions)
+      api_mets=[]
+      new_mets=[]
+      del_mets=[]
+      api_functions.each { |f|
+        all_found=all_functions.select { |func| func.basename == f.basename }
+        if all_found.empty?
+          EasySwig::Logger.log("WARNING: Function not found: #{f.to_str}")
+        del_mets << f
+        next
+        end
+        if all_found.size > 1
+          EasySwig::Logger.log("WARNING: Found several matching functions for #{f.to_str}: "+all_found.map { |func| func.basename+func.args }.join(" -- ")+"All of them will be matched")
+          all_found[1..-1].each { |found|
+            new_met=f.clone
+            new_met.assoc_with_node found
+            new_mets << new_met
+          }
+        end
+        f.assoc_with_node all_found[0]
+        api_mets.push(*all_found)
+      }
+      api_functions.reject! { |f| del_mets.include?(f)}      
+      api_functions.push(*new_mets)
+      ignored_functions.push(*(all_functions - api_mets));
+    end
+
+    def assoc_members(all_members, api_members, ignored_members)
+      api_mbrs=[]
+      del_mbrs=[]
+
+      api_members.each { |s|
+        found=nil
+        all_found=all_members.select { |str| str.basename == s.basename }
+        if all_found.empty?
+          EasySwig::Logger.log("WARNING: Member not found: #{s.to_str}")
+          del_mbrs << s
+          next
+        end
+        if all_found.size > 1
+          EasySwig::Logger.log("WARNING: Found several matching members for #{s.to_str}: "+all_found.join(" -- ")+" Only the first one will be matched")
+        end
+        found=all_found[0]
+        s.assoc_with_node found
+        api_mbrs.push found
+      }
+      api_members.reject! { |m| del_mbrs.include?(m) }
+      ignored_members.push(*(all_members - api_mbrs));
+    end
+  end
+end

data/lib/apinodes/api_variable.rb

@@ -0,0 +1,12 @@
+module EasySwig
+
+  class ApiVariable < ApiNode
+
+    attr_accessor :match_type
+
+    def api_nodes
+      self
+    end
+
+  end
+end

data/lib/apinodes/inc_file.rb

@@ -0,0 +1,118 @@
+module EasySwig
+
+  class IncFile < ApiNode
+
+    attr_accessor :api_namespaces
+    attr_accessor :ignored_namespaces
+    attr_accessor :api_classes
+    attr_accessor :ignored_classes
+    attr_accessor :api_enums
+    attr_accessor :ignored_enums
+    attr_accessor :api_functions
+    attr_accessor :ignored_functions
+    attr_accessor :api_variables
+    attr_accessor :ignored_variables
+    attr_accessor :num_included
+    attr_accessor :num_including
+    attr_accessor :wrap_functions
+    attr_accessor :wrap_variables
+    attr_accessor :wrap_enums
+
+    def initialize(hash)
+      super(hash)
+      @api_namespaces=[]
+      @ignored_namespaces=[]
+      @api_classes=[]
+      @ignored_classes=[]
+      @api_enums=[]
+      @ignored_enums=[]
+      @api_functions=[]
+      @ignored_functions=[]
+      @api_variables=[]
+      @ignored_variables=[]
+      @wrap_functions = true
+      @wrap_variables = true
+      @wrap_enums = true
+      @added_nodes = {}
+    end
+    
+    def <=> other
+      if @num_including == 0 && other.num_including == 0 
+        return(@num_included - @num_including)  <=> (other.num_included- other.num_including)
+      end
+      return 1 if @num_including == 0
+      return -1 if other.num_including == 0
+      return(@num_included - @num_including)  <=> (other.num_included- other.num_including)
+    end
+
+    def assoc_inner_node(api_node)
+    	return if @added_nodes[api_node.wrapped_node]
+      case api_node.node_type
+        when "namespace"
+          @api_namespaces << api_node
+        when "function"
+          @api_functions << api_node
+        when "variable"
+          @api_variables << api_node
+        when "enum"
+          @api_enums << api_node
+        when "class"
+          @api_classes << api_node
+      end
+    	@added_nodes[api_node.wrapped_node] = 1
+    end
+    
+    def assoc_with_node(node)
+      super(node)
+      @num_included = files_included.size
+      @num_including = files_including.size
+      all_functions = node.functions
+			all_enums = node.enums
+			all_variables = node.variables
+			
+			if @wrap_functions
+				all_functions.each { |f|
+						hash = {'features' => @features, 'node_type' => 'function', 'parent' => self, 'basename' => f.basename }
+						@api_functions << ApiFunction.new(hash).assoc_with_node(f)
+				}
+			end
+			if @wrap_variables
+				all_variables.each { |v|
+						hash = {'features' => @features, 'node_type' => 'variable', 'parent' => self, 'basename' => v.basename}
+						@api_variables << ApiVariable.new(hash).assoc_with_node(v)
+				}
+			end
+			if @wrap_enums
+				all_enums.each { |e|
+						hash = {'features' => @features, 'node_type' => 'enum', 'parent' => self, 'basename' => e.basename }
+						@api_enums << ApiEnum.new(hash).assoc_with_node(e)
+				}
+			end
+      self
+    end
+
+    def ignore_inner_nodes
+      aux = @api_namespaces.map { |n| n.wrapped_node }
+      @ignored_namespaces = namespaces.select { |ns| aux.include?(ns) == false }
+      aux = @api_functions.map { |n| n.wrapped_node }
+      @ignored_functions = functions.select { |func| aux.include?(func) == false }
+      aux = @api_variables.map { |n| n.wrapped_node }
+      @ignored_variables = variables.select { |var| aux.include?(var) == false }
+      aux = @api_enums.map { |n| n.wrapped_node }
+      @ignored_enums = enums.select { |enum| aux.include?(enum) == false }
+      aux = @api_classes.map { |n| n.wrapped_node }
+      file_classes = classes + structs
+      del = []
+      file_classes.each { |file_cls|
+        @api_classes.each { |api_cls|
+          if api_cls.api_innerclasses.map { |n| n.wrapped_node }.include?(file_cls)
+          del << file_cls
+          end
+        }
+      }
+      @ignored_classes = file_classes.select { |cls| !aux.include?(cls) && !del.include?(cls) }
+      @ignored_classes
+    end
+
+  end
+end

data/lib/config.rb

@@ -0,0 +1,56 @@
+module EasySwig
+
+	# Generation Settings
+  class Config
+    # [String] Working directory. Defaults to current working directory
+    attr_accessor :default_dir
+  	# [String] Name of the module. Used to name generated resources. Defaults to the name of the default (working) directory
+    attr_accessor :module_name
+    # [String] Directory generated by Doxygen (which include a /xml subdirectory for all XML files. Defaults to: path/to/working/dir/easy-swig/doxygen
+    attr_accessor :doxy_dir
+    # [String] Directory for your project's header files. Defaults to: path/to/working/dir/include
+    attr_accessor :headers_dir
+    # [String] CSV configuration file input. Defaults to: path/to/working/dir/api.csv
+    attr_accessor :csv_file
+    # [String] Output directory for SWIG generated files. Defaults to : path/to/working/dir/easy-swig/swig
+    attr_accessor :output_dir
+    # [String] Output directory for Easy-Swig generated .i file(s) aka. 'target'. Defaults to path/to/working/dir/easy-swig/generate
+    attr_accessor :generate_dir
+    # [String] Instructs Doxygen to also generate HTML documentation for the header files. Defaults to nil (false)
+    attr_accessor :html
+    # [String] Target language for SWIG. Defaults to 'csharp' (C#)
+    attr_accessor :lang
+    # [String] Custom .i file to be appended at the beginning of the generated .i target. Used for advanced configuration
+    # 	Defaults to path/to/working/dir/custom_config.i
+    attr_accessor :custom_file
+    # [String] Target .i file as input for SWIG. If a directory SWIG will be invoked once for every found .i file
+    # 	Defaults to path/to/working/dir/easy-swig/generate/<MODULE_NAME>.i
+    attr_accessor :target_file
+    # [Array<String>] System include directories. Defaults to Linux include directory: ["/usr/include"]
+    attr_accessor :includes_dir
+    # [String] Special support for the Standard Template Library. Values 'YES'/'NO' (defaults to 'YES') 
+    attr_accessor :stl_support
+    
+    # Creates a new Configutation using the default values for a given directory
+    # @param [String] default_dir Working directory
+    def initialize(default_dir = nil)
+    	@default_dir = default_dir
+    	set_defaults
+    end
+
+    def set_defaults
+      @default_dir ||= Dir.getwd
+      @module_name ||= File.basename(@default_dir)
+      @output_dir ||= "#{@default_dir}/easy-swig/swig"
+      @doxy_dir ||= "#{@default_dir}/easy-swig/doxygen"
+      @generate_dir ||= "#{@default_dir}/easy-swig/generate"
+      @headers_dir ||= "#{@default_dir}/include"
+      @csv_file ||= "#{@default_dir}/api.csv"
+      @custom_file ||= "#{@default_dir}/custom_config.i"
+      @lang ||= "csharp"
+      @stl_support ||= 'YES'
+      @target_file ||= "#{@default_dir}/easy-swig/generate/#{@lang}/#{@module_name}.i"
+      @includes_dir ||= ["/usr/include"]
+    end
+  end
+end

data/lib/csharp/csharp_features.rb

@@ -0,0 +1,100 @@
+module EasySwig
+  module Csharp
+
+    class CsharpFeatures < EasySwig::Features
+
+      attr_accessor :properties
+      attr_accessor :struct
+      attr_accessor :director
+      attr_accessor :immutable
+      attr_accessor :partial
+
+      def to_s
+        s = @properties ? 'properties': ''
+        s << @struct ? 'struct' : ''
+        s << @director ? 'director' : ''
+        s << @immutable ? 'immutable' : ''
+      end
+
+      def to_str
+        to_s
+      end
+
+      def infer_basename(node)
+        aux = node.target_name.gsub(/_([a-z])/i) { |match|
+          $1.upcase
+        }
+        case node.node_type
+          when 'function', 'attribute', 'variable'
+            node.basename = aux.gsub(/^([A-Z])/) { |match|
+              $1.downcase
+            }
+          when 'method'
+            if node.constructor?
+            node.basename =  aux
+            else
+              node.basename = aux.gsub(/^([A-Z])/) { |match|
+                $1.downcase
+              }
+            end
+          when 'class', 'enum'
+            node.basename = aux.gsub(/^([a-z])/) { |match|
+              $1.upcase
+            }
+          when 'namespace'
+            node.basename = node.target_name.gsub(".", "::")
+        else
+        super node
+        end
+
+      end
+
+      def ignore_operator(name)
+        ['operator+','operator+=', 'operator-',
+          'operator-=', 'operator*', 'operator*=',
+          'operator/', 'operator/=', 'operator<',
+          'operator<=', 'operator>', 'operator>=',
+          'operator=', 'operator[]', 'operator==',
+          'operator!=', 'operator^', 'operator~',
+          'operator%', 'operator&', 'operator|',
+          'operator&&', 'operator||', 'operator<<',
+          'operator>>'].include?(name)
+      end
+
+      def infer_target_name(node)
+        case node.node_type
+          when 'method'
+            if node.basename.start_with? '~'
+              node.target_name = 'Dispose'
+            	return
+            end
+            if @properties
+              node.target_name ||= node.setter_for
+              node.target_name ||= node.getter_for
+              if node.target_name
+              	list = []
+              	wnode = node.parent.wrapped_node
+								list.push(*wnode.methods)
+								list.push(*wnode.attributes)             	
+              	if list.any? { |m| m.basename.capitalize == node.target_name.capitalize }
+                	node.target_name.prepend('_')
+                end
+              end
+            end
+            node.target_name ||= node.basename
+            node.target_name = node.target_name.gsub(/^(_?)([a-z])/) { |match|
+              $2.upcase.prepend $1
+            }
+          when 'function', 'variable', 'attribute'
+            node.target_name ||= node.basename.gsub(/^([a-z])/) { |match|
+              $1.upcase
+            }
+          when 'namespace'
+            node.target_name ||= node.basename.gsub("::", ".")
+        else
+        super node
+        end
+      end
+    end
+  end
+end

data/lib/csharp/generators/csharp_class_generator.rb

@@ -0,0 +1,14 @@
+module EasySwig
+
+  class CSharpClassGenerator < ClassGenerator
+
+    def gen_methods
+      swig_file = super
+      # Takes the opportunity to also apply partial class typemaps
+      if @api_class.features.partial
+        swig_file << %Q{\n%typemap(csclassmodifiers) #{@api_class.name} "public partial class"\n}
+      end
+      swig_file
+    end
+  end
+end

data/lib/csharp/generators/csharp_generator.rb

@@ -0,0 +1,17 @@
+module EasySwig
+  module Csharp
+
+    class CsharpGenerator < EasySwig::Generator
+
+      def initialize(hfiles, api_namespace, config, log)
+        super(hfiles, api_namespace, config, log)
+      end
+
+      def init_generators
+        @class_generator = EasySwig::CSharpClassGenerator
+        @namespace_generator = EasySwig::CSharpNamespaceGenerator
+        @hfile_generator = EasySwig::HFileGenerator
+      end
+    end
+  end
+end

data/lib/csharp/generators/csharp_namespace_generator.rb

@@ -0,0 +1,33 @@
+module EasySwig
+
+  class CSharpNamespaceGenerator < NamespaceGenerator
+  
+  protected
+		
+		def generate_functions
+			swig_file = ''
+			@api_ns.ignored_functions.each { |m|
+				swig_file << %Q{%rename("$ignore") #{m.name};} + "\n"
+			}
+			@api_ns.api_functions.each { |m|
+				swig_file << %Q{%rename(#{m.target_name}) #{m.name};} + "\n"
+			}
+			swig_file
+		end
+		
+		def generate_variables
+			swig_file = ''
+			@api_ns.ignored_variables.each { |m|
+				swig_file << %Q{%rename("$ignore") #{m.name};} + "\n"
+			}
+			@api_ns.api_variables.each { |m|
+				if type_is_blacklisted?(m)
+					swig_file << %Q{%rename("$ignore") #{m.name};} + "\n"
+				else
+					swig_file << %Q{%rename(#{m.target_name}) #{m.name};} + "\n"
+				end
+			}
+			swig_file
+		end
+  end
+ end