rbplusplus 0.8 → 0.9

data/lib/rbplusplus/builders/types_manager.rb

@@ -1,93 +0,0 @@
-module RbPlusPlus
-  module Builders
-
-    # This is a singleton class that takes care of handling any to_ruby and from_ruby 
-    # definitions this wrapper might need. This is pulled out seperate from other builders
-    # because of C++ coding and compiling restrictions. Mainly, 
-    #
-    # 1. All cpp/hpp files where Rice needs to know about a given type needs to know about any to_/from_ruby definitions of that type
-    # 2. The actual definition of these methods can only be in one place or we get compiler redefinition errors.
-    class TypesManager
-      include Singleton
-
-      # Forward off all calls to the singleton instance of this method. 
-      # This allows one to use this class as if it's a bunch of class methods. E.g.:
-      #
-      #   TypesManager.build_const_converter(type)
-      #
-      def self.method_missing(method, *args)
-        if TypesManager.instance.respond_to?(method)
-          TypesManager.instance.send(method, *args)
-        else
-          super
-        end
-      end
-
-      attr_accessor :body, :prototypes, :includes
-
-      def initialize
-        @consts_wrapped = []
-        @body = []
-        @prototypes = []
-        @includes = []
-      end
-
-      # Some libraries have really bad namespace declarations
-      # so we allow for 2 methods of including files
-      # 1.  trace the class definition to the parent file
-      # 2.  explicitly declare which files to include in every generated source
-      #
-      def add_include_for(type)
-        file = type.file_name(false)
-        if Base.sources.include? file
-          @includes << "#include \"#{file}\""
-        else
-          Base.sources.each do |header|
-            @includes << "#include \"#{header}\""
-          end
-        end  
-      end
-      
-      # Rice doesn't automatically handle all to_ / from_ruby conversions for a given type.
-      # A common construct is the +const Type&+ variable, which we need to manually handle.
-      def build_const_converter(type)
-        type = type.is_a?(RbGCCXML::Type) ? type.base_type : type
-
-        # Don't need to deal with fundamental types
-        return if type.is_a?(RbGCCXML::FundamentalType)
-
-        full_name = type.qualified_name
-
-        # Only wrap once
-        # TODO cleaner way of doing this
-        return if @consts_wrapped.include?(full_name)
-
-        # Some types are already handled by Rice, ignore such types
-        return if full_name =~ /std::string/
-
-        @consts_wrapped << full_name
-
-        # Enumerations are handled slightly differently
-        class_type = if type.is_a?(RbGCCXML::Enumeration)
-                       "new #{full_name}(a)"
-                     else
-                       "(#{full_name} *)&a"
-                     end
-
-        @includes << "#include <rice/Object.hpp>"
-        @includes << "#include <rice/Data_Object.hpp>"
-        @includes << "#include <rice/Data_Type.hpp>"
-        add_include_for type
-
-        @body << "template<>"
-        @body << "Rice::Object to_ruby<#{full_name} >(#{full_name} const & a) {"
-        @body << "\treturn Rice::Data_Object<#{full_name} >(#{class_type}, Rice::Data_Type<#{full_name} >::klass(), 0, 0);"
-        @body << "}"
-
-        @prototypes << "template<>"
-        @prototypes << "Rice::Object to_ruby<#{full_name} >(#{full_name} const & a);"
-      end
-
-    end
-  end
-end

data/lib/rbplusplus/transformers/constructor.rb

@@ -1,4 +0,0 @@
-module RbGCCXML
-  class Constructor #:nodoc:
-  end
-end

data/lib/rbplusplus/transformers/module.rb

@@ -1,71 +0,0 @@
-module RbPlusPlus
-  class RbModule
-    # Helper function for moving pieces of an API into other Ruby locations, eg from a Class to a Module, 
-    # from global functions to a Class, or from Module to Module.
-    #
-    # Module may include Functions
-    #   e.module "System" do |m|
-    #     m.includes node.functions("print").wrap_as("puts") # Moves the ::print function into the System module
-    #
-    #     m.include node.classes("Vector3") # Explicitly put Vector3 class in the System module
-    #   end
-    #
-    def includes(val)
-      if is_a?(val, RbGCCXML::Function)
-        reference_function(val)
-      elsif is_a?(val, RbGCCXML::Class)
-        reference_class(val)
-      elsif is_a?(val, RbGCCXML::Struct)
-        reference_struct(val)
-      else
-        raise "Cannot use #{self.class}#includes for type '#{val.class}'"
-      end
-    end
-    
-    def functions #:nodoc:
-      functions = @functions || []
-      functions << @node.functions if @node
-      functions.flatten
-    end
-    
-    def classes #:nodoc:
-      classes = @classes || []
-      classes << @node.classes if @node
-      classes.flatten
-    end
-  
-    def structs #:nodoc:
-      structs = @structs || []
-      structs << @node.structs if @node
-      structs.flatten
-    end
-    
-    private
-
-    # Map a function from a different namespace
-    def reference_function(val) #:nodoc:
-      @functions ||= []
-      @functions << NodeReference.new(val)
-      val.moved=true 
-    end
-    
-    # Map a class from a different namespace
-    def reference_class(val) #:nodoc:
-      @classes ||= []
-      @classes << NodeReference.new(val)
-      val.moved=true
-    end
-    
-    def reference_struct(val) #:nodoc:
-      @structs ||= []
-      @structs << NodeReference.new(val)
-      val.moved=true   
-    end
-        
-    def is_a?(val, klass) #:nodoc:
-      return true if val.is_a?(klass)
-      return true if val.is_a?(NodeReference) && val.references?(klass)
-      return false
-    end
-  end
-end

data/lib/rbplusplus/transformers/node_reference.rb

@@ -1,30 +0,0 @@
-module RbPlusPlus
-  class NodeReference #:nodoc:
-    # Takes the delegate object as input
-    def initialize(from)
-      @delegate = from
-    end
-    
-    # Delegate
-    def method_missing(name, *args)
-      @delegate.send name, *args
-    end
-    
-    # Always false
-    def moved?
-      false
-    end
-    
-    # Delegate
-    def methods(*args)
-      @delegate.methods *args
-    end
-    
-    # Returns true if the class references the specified class
-    def references?(klass)
-      return true if @delegate.is_a?(klass)
-      return true if @delegate.is_a?(NodeReference) && @delegate.references?(klass)
-      return false
-    end 
-  end
-end

data/test/headers/ugly_helper.h

@@ -1,18 +0,0 @@
-#ifndef UGLY_HELPER
-#define UGLY_HELPER
-
-#include "rice/Class.hpp"
-#include "rice/Data_Type.hpp"
-#include "rice/Constructor.hpp"
-#include "rice/Enum.hpp"
-#include "rice/to_from_ruby.hpp"
-#include "rice/Address_Registration_Guard.hpp"
-
-#include <ruby.h>
-#include "ugly_interface_ns.h"
-
-inline UI::C_UIVector *newInstanceButBetter(Rice::Object *self) {
-  return new UI::C_UIVector();
-}
-
-#endif

data/test/object_persistence_test.rb

@@ -1,44 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-context "Object Persistence" do
-  
-  def validate(node)
-    namespaces = node.namespaces
-    
-    node.namespaces.each_with_index do |n, i|
-    
-      #puts "#{node.name}::#{n.name}"
-      namespaces[i].object_id.should == n.object_id
-      
-      classes = n.classes
-      classes.each_with_index do |cls, j|
-        namespaces[i].classes[j].object_id.should == cls.object_id
-      
-        methods = cls.methods
-        methods.each_with_index do |m, k|
-          #puts "#{n.name}::#{cls.name}::#{m.name}"
-          namespaces[i].classes[j].methods[k].object_id.should == m.object_id
-        end 
-      end
-
-      functions = n.functions  
-      functions.each_with_index do |funct, j|
-     #   puts "#{n.name}::#{funct.name}"
-        namespaces[i].functions[j].object_id.should == funct.object_id
-      end
-      
-      validate n
-    end
-
-  end
-
-  specify "seperate query should lazy initialize objects" do
-    Extension.new "ui" do |e|
-      e.sources full_dir("headers/ugly_interface_ns.h")
-      node = e.namespace("UI")
-      validate(node)
-    end
-  end 
-end
-    
-