testability-driver 1.2.1 → 1.3.0

data/lib/tdriver/base/behaviour/behaviours/object_behaviour_composition.rb

@@ -17,7 +17,7 @@
 ## 
 ############################################################################
 
-# deprecated: use MobyUtil::BehaviourFactory instead
+# deprecated: use TDriver::BehaviourFactory instead
 
 =begin
 module MobyBehaviour
@@ -72,7 +72,7 @@ module MobyBehaviour
 
 			sut = ( sut = self ).kind_of?( MobyBase::SUT ) ? sut : sut.sut 
 
-			MobyBase::BehaviourFactory.instance.apply_behaviour!( { :sut_type => [ '*', sut.ui_type ], :version => [ '*', sut.ui_version ] }.merge( rules ).merge( { :object => self } ) )
+			TDriver::BehaviourFactory.apply_behaviour( { :sut_type => [ '*', sut.ui_type ], :version => [ '*', sut.ui_version ] }.merge( rules ).merge( { :object => self } ) )
 
 		end
 

data/lib/tdriver/base/behaviour/behaviours/object_behaviour_description.rb

@@ -67,7 +67,15 @@ module MobyBehaviour
     #
 		def behaviours( return_indexes = false )
 
-			return_indexes ? @object_behaviours : @object_behaviours.collect{ | index | MobyBase::BehaviourFactory.instance.get_behaviour_at_index( index )[ :name ] }.uniq.compact.sort
+      if return_indexes
+
+        @object_behaviours
+
+      else
+
+        TDriver::BehaviourFactory.collect_behaviours( :index => @object_behaviours ).collect{ | behaviour | behaviour[ :name ] }.uniq.compact.sort
+
+      end
 
 		end
 
@@ -79,11 +87,21 @@ module MobyBehaviour
     #  example: ["application?", "close", "closable?", "describe"]
 		def object_methods
 
-			[].tap{ | methods | 
-				@object_behaviours.each{ | index | 
-					MobyBase::BehaviourFactory.instance.get_behaviour_at_index( index )[ :methods ].keys.each{ | key | methods << key.to_s }
-				} 
-			}.uniq.compact.sort
+      TDriver::BehaviourFactory.collect_behaviours( :index => @object_behaviours ).inject( [] ){ | result, behaviour |
+
+        # append method names to result array
+        result.concat( 
+
+          behaviour[ :methods ].keys.collect{ | key | 
+
+            # make sure that method name is returned in type of string
+            key.to_s 
+
+          } 
+
+        ) 
+
+      }.uniq.compact.sort
 
 		end
 
@@ -134,52 +152,44 @@ module MobyBehaviour
     #
 		def describe_method( method_name, print = true, return_result = false )
 			
-      # verify that method_name is type of Symbol or String 
-      method_name.check_type( [ Symbol, String ], "Wrong argument type $1 for method name (expected $2)" )
-
-			# convert to symbol if method_name is a string
-			method_name = method_name.to_sym if method_name.kind_of?( String )
+      # verify that method_name is type of Symbol or String and convert it to Symbol
+      method_name = method_name.check_type( [ Symbol, String ], "wrong argument type $1 for method name (expected $2)" ).to_s
 
-			# print result to stdout if argument not boolean
-			print = true unless [ TrueClass, FalseClass ].include?( print.class )
+      # verify that print argument is boolean
+      print = print.check_type( [ TrueClass, FalseClass ], "wrong argument type $1 for verbose output (expected $2)" ).true?
 
 			# return result not printed out to stdout 
-			return_result = true unless print
+			return_result = true if print.false?
 
-			result_hash = nil
+      behaviours = TDriver::BehaviourFactory.collect_behaviours( :index => @object_behaviours ).select{ | behaviour |
 
-			@object_behaviours.each{ | index | 
+        behaviour[ :methods ].keys.include?( method_name )
 
-				behaviour = MobyBase::BehaviourFactory.instance.get_behaviour_at_index( index )
+      }.compact.last
 
-				if behaviour[ :methods ].keys.include? method_name
-					method_details = behaviour[:methods][ method_name ]
-					result_hash = { :description => method_details[ :description ], :example => method_details[ :example ] }
-					break;
-				end
-				
-			}
+      # verify that method was found
+      behaviours.not_blank "Test object type of #{ @type } does not have method #{ method_name.inspect }"
 
-			Kernel::raise ArgumentError.new( "Test object type of %s does not have method %s" % [ self.type, method_name ] ) if result_hash.nil?
+      result = { 
+        :name => method_name, 
+        :description => behaviours[ :methods ][ method_name ][ :description ], 
+        :example => behaviours[ :methods ][ method_name ][ :example ] 
+      }
 
-			if print
+      if print
 
-				result = ""
+        result = [ :name, :description, :example ].inject( "" ){ | tmp_result, key |
 
-				[ :description, :example ].each{ | key | 
-					tmp_hash = result_hash[ key ]
-					result << "\n#{ key.to_s.capitalize }:\n#{ tmp_hash }\n"
-				}
+					tmp_result << "\n#{ key.to_s.capitalize }:\n#{ result[ key ] }\n"
 
-				puts result
+        }
 
-			else
+        puts result
 
-				result = result_hash
+      end
 
-			end
-
-			( return_result ? result : nil )
+      # result
+      return_result ? result : nil    
 
 		end
 

data/lib/tdriver/base/behaviour/factory.rb

@@ -17,488 +17,366 @@
 ## 
 ############################################################################
 
-module MobyBase
+module TDriver
 
-  # TODO: document BehaviourFactory class
   class BehaviourFactory
-
-  include Singleton
   
-  def initialize
-
-    @@behaviours = []
-    @@behaviours_cache = {}
-    @@modules_cache = {}
-
-    @@plugin_cache = []
-    
-    # behaviour xml files path
-    @@path = File.join( MobyUtil::FileHelper.tdriver_home, '/behaviours/*.xml' )
-
-    parse_behaviour_files( 
-
-      load_behaviours( @@path ) 
-
-    )
-
-  end
-
-  public
-
-  def to_xml( rules = {} ) 
-
-    @_method_index = nil
-
-    rules.default = [ '*' ]
-
-    rules.each_pair{ | key, value |
-
-    rules[ key ] = [ value ] if value.kind_of?( String )
-
-    }
-
-    MobyUtil::XML.build{
-
-    behaviours{
+    class << self
 
-      @@behaviours.each_index{ | index |
+    public
 
-      @_method_index = index
+      # initialize behaviours factory
+      def init( options )
 
-      behaviour = @@behaviours[ @_method_index ]
+        # verify that argument is type of hash
+        options.check_type Hash, 'wrong argument type $1 for TDriver::BehaviourFactory#init options argument (expected $2)'
 
-      if ( ( rules[ :name ] == behaviour[ :name ] ) ||  
+        # load behaviour configuration files
+        load_behaviours( 
 
-        ( rules[ :name ] == [ '*' ] ) &&
-
-#        ( !( rules[ :sut_type ] & behaviour[ :sut_type ] ).empty? ) && 
-        ( !( rules[ :input_type ] & behaviour[ :input_type ] ).empty? ) && 
-        ( !( rules[ :object_type ] & behaviour[ :object_type ] ).empty? ) && 
-        ( !( rules[ :version ] & behaviour[ :version ] ).empty? )
-
-        ) 
-
-        behaviour( :name => @@behaviours[ @_method_index ][ :name ], :object_type => @@behaviours[ @_method_index ][ :object_type ].join(";") ){ 
-        object_methods{
-          @@behaviours[ @_method_index ][ :methods ].each { | key, value |
-          object_method( :name => key.to_s ) {  
-            description( value[:description] )
-            example( value[:example] )
-          }
-          }
-        }
-        }
+          options.require_key( :path, 'required key $1 not found from TDriver::BehaviourFactory#init options argument' )
+          
+        )
 
       end
+      
+      # reset class configuration
+      def reset
 
-      }
-
-    }
-
-    }.to_xml
-
-  end
-
-  def get_behaviour_at_index( index )
-
-    result = @@behaviours[ index ]
-
-    if result.nil? 
-
-    Kernel::raise RuntimeError.new( "No behaviour at index #{ index }" )
+        # reset default values
+        initialize_class      
+      
+      end
 
-    else
+      # TODO: document me
+      def apply_behaviour( rule )
+        
+        # verify that rule is given as hash
+        rule.check_type Hash, 'wrong argument type $1 for TDriver::BehaviourFactory#apply_behaviour rule argument (expected $2)'
 
-    result
+        # empty collected indexes variable
+        collected_indexes = [] 
+        
+        # retrieve object from hash
+        _object = rule[ :object ]
 
-    end
+        # generate cache key, drop :object value from hash
+        cache_key = rule.reject{ | key, value | key == :object }.hash
 
-  end
-  
-  # TODO: document me
-  def reset_modules_cache
-  
-    # reset modules cache hash; needed if new behaviour plugins loaded later than when initializing TDriver/SUT
-    @@modules_cache.clear
-  
-  end
+        # retrieve behaviour from cache if found
+        if @behaviours_cache.has_key?( cache_key )
+        
+          behaviours = @behaviours_cache[ cache_key ]
+        
+        else
 
-  def apply_behaviour!( rules = {} )
+          # collect behaviours that meets given rules
+          behaviours = collect_behaviours( rule )
 
-    # merge user-defined rules on top of default rules set
-    #rules = { :sut_type => ['*'], :object_type => ['*'], :input_type => ['*'], :version => ['*'] }.merge!( rules )
+          # store behaviour collection to cache for future reuse
+          @behaviours_cache[ cache_key ] = behaviours
 
-    raise ArgumentError, 'Target object not defined in rules hash' if rules[ :object ].nil?      
+        end
 
-    rules.default = ['*']
+        # iterate through each collected behaviour 
+        behaviours.each do | behaviour |
 
-    # retrieve enabled plugins from PluginService
-    enabled_plugins = TDriver::PluginService.enabled_plugins 
+          begin
+        
+            # retrieve module from hash
+            _module = behaviour[ :module ]
 
-    # apply behaviours to target object
-    get_object_behaviours( rules ).each{ | behaviour_index |
+            unless _module.kind_of?( Module )
 
-      behaviour_data = @@behaviours[ behaviour_index ]
+              # retrieve behaviour module
+              _module = MobyUtil::KernelHelper.get_constant( _module.to_s ) 
 
-      # skip if required plugin is not registered or enabled; compare requires array and enabled_plugins array
-      next unless ( behaviour_data[ :requires ] - enabled_plugins ).empty?
+              # store pointer to module (implementation) back to hash
+              behaviour[ :module ] = _module
 
-      begin
+            end
 
-        # retrieve behaviour module from cache and extend target object
-        rules[ :object ].extend( 
+            # extend target object with behaviour module
+            _object.extend( _module )
 
-          @@modules_cache.fetch( behaviour_data[ :module ][ :name ] ){ | name |                  
+            # store behaviour indexes
+            collected_indexes << behaviour[ :index ]
 
-            # ... or store to cache for the next time if not found 
-            @@modules_cache[ name ] = MobyUtil::KernelHelper.get_constant( name )
+          rescue NameError
 
-          } 
+            raise NameError, "Implementation for #{ behaviour[ :name ] } behaviour does not exist. (#{ _module })"
+          
+          rescue
+          
+            raise RuntimeError, "Error while applying #{ behaviour[ :name ] } (#{ _module }) behaviour to target object due to #{ $!.message } (#{ $!.class })"
+          
+          end
+        
+        end # behaviours.each
 
-        )
+        # retrieve objects behaviour index array if already set
+        collected_indexes = _object.instance_variable_get( :@object_behaviours ) | collected_indexes if _object.instance_variable_defined?( :@object_behaviours )
 
-      rescue NameError
+        # add behaviour information to test object
+        _object.instance_variable_set( :@object_behaviours, collected_indexes )
+      
+      end
 
-        raise NameError, "Implementation for behaviour #{ behaviour_data[ :name ] } does not exist. (#{ behaviour_data[ :module ][ :name ] })"
+      # TODO: document me
+      def collect_behaviours( rule )
 
+        # retrieve enabled plugins from PluginService
+        enabled_plugins = TDriver::PluginService.enabled_plugins 
 
-      rescue
+        # default value for rule if not defined
+        rule.default = [ '*' ]
 
-        raise RuntimeError, "Error while applying #{ behaviour_data[ :name ] } (#{ behaviour_data[ :module ][ :name ] }) behaviour to target object. Reason: #{ $!.message } (#{ $!.class })"
+        # store as local variable for less AST lookups
+        _index        = rule.fetch( :index ){ [] }
+        _object_type  = rule[ :object_type  ]
+        _input_type   = rule[ :input_type   ]
+        _env          = rule[ :env          ]
+        _version      = rule[ :version      ]
 
-      end
+        @behaviours.select do | behaviour |
 
-      # add behaviour information to test object
-      rules[ :object ].instance_exec{ 
+          # skip if required plugin is not registered or enabled; compare requires array and enabled_plugins array
+          next unless ( behaviour[ :requires ] - enabled_plugins ).empty?
 
-        @object_behaviours.push( behaviour_index ) unless @object_behaviours.include?( behaviour_index )
+          # match other rules if no exact index given          
+          if _index.empty?
 
-      }
+            case rule[ :name ]
+            
+              when behaviour[ :name ]
+              
+                # exact match with name
+                true
+              
+              when ['*']
 
-    }
+                # compare rules and behaviour attributes
+                !( _object_type & behaviour[ :object_type ] ).empty? && 
+                !( _input_type  & behaviour[ :input_type  ] ).empty? &&
+                !( _env         & behaviour[ :env         ] ).empty? && 
+                !( _version     & behaviour[ :version     ] ).empty? 
 
-  end
+            else
+              
+              false
 
-  private
+            end
 
-  def load_behaviours( behaviour_files )
+          else
 
-    behaviours_data = []
+            # index given
+            true if Array( _index ).include?( behaviour[ :index ] )
 
-    @file_name = ""
+          end
 
-    begin
+        end # behaviours.select
+      
+      end
+ 
+      # remove me when migration ready
+      def apply_behaviour!( *args )
 
-    Dir.glob( behaviour_files ).each{ | behaviour | 
+        warn_caller '$1:$2 warning: deprecated method apply_behaviour!; please use TDriver::BehaviourFactory.apply_behaviour instead'
 
-      @file_name = behaviour
+        apply_behaviour( *args )
 
-      behaviours_data << { :filename => @file_name, :xml => MobyUtil::FileHelper.get_file( @file_name ) }
+      end
 
-    }
+      # TODO: document me
+      def to_xml( rule )
 
-    rescue MobyUtil::EmptyFilenameError
+        MobyUtil::XML.build{ | xml |
 
-      raise EmptyFilenameError, "Unable to load behaviours xml file due to filename is empty or nil" 
+          # root element
+          xml.behaviours{
 
-    rescue MobyUtil::FileNotFoundError
+            # iterate each behaviour that meets the rule
+            collect_behaviours( rule ).each{ | behaviour | 
 
-      raise
+              # behaviour element
+              xml.behaviour( :name => behaviour[ :name ], :object_type => behaviour[ :object_type ].sort.join(";") ){
 
-    rescue IOError
+                # behaviour methods element
+                xml.object_methods{
 
-      raise IOError, "Error occured while loading behaviours xml file %s. Reason: %s" % [ @file_name, $!.message ]
+                  behaviour[ :methods ].each_pair{ | key, value |
 
-    rescue
+                    xml.object_method( :name => key.to_s ){
 
-      raise RuntimeError, "Error occured while parsing behaviours xml file %s. Reason: %s (%s)" % [ @file_name, $!.message, $!.class ]
+                      xml.description value[ :description ]
+                      xml.example     value[ :example     ]
 
-    end
+                    } # object_method
 
-    behaviours_data
+                  } # methods.each_pair
 
-  end
+                } # object_methods
 
-  def parse_behaviour_files( behaviour_files )
+              }  # behaviour
 
-    behaviour_files.each{ | behaviours | 
+            } # behaviours.each
 
-      begin
+          } # root
 
-        # skip parsing the xml if string is empty
-        next if behaviours[ :xml ].empty?
+        }.to_xml
 
-        # parse behaviour xml
-        document = MobyUtil::XML.parse_string( behaviours[ :xml ] )
+      end
 
-      rescue
+      # TODO: document me
+      def reset_cache
 
-        raise MobyUtil::XML::ParseError, "Error occured while parsing behaviour XML file #{ behaviours[ :filename ] }. Error: #{ $!.message }"
+        # reset behaviour cache
+        @behaviours_cache = {}
 
       end
 
-      # process each behaviours element
-      document.root.xpath( "/behaviours" ).each{ | behaviours_element |
+    private
       
-        # retrieve root attributes
-        root_attributes = behaviours_element.attributes
-
-        # process each behaviour element      
-        behaviours_element.xpath( "behaviour" ).each{ | node |
-
-          # retrieve behaviour attributes & module node
-          attributes = node.attributes
-
-          name = attributes[ "name" ].to_s
-          object_type = attributes[ "object_type" ].to_s
-          input_type = attributes[ "input_type" ].to_s
-          sut_type = attributes[ "sut_type" ].to_s
-          version = attributes[ "version" ].to_s
-
-          env = ( attributes[ "env" ] || '*' ).to_s 
+      # private methods and variables
+      def initialize_class
 
-          module_node = node.xpath( 'module' ).first
-          
-          # verify that all required attributes and nodes are found in behaviour xml node
-          name.not_empty "Behaviour element does not have name (name) attribute defined, please see behaviour XML files", RuntimeError
-          
-          object_type.not_empty "Behaviour element does not have target object type (object_type) attribute defined, please see #{ name } in behaviour XML files", RuntimeError
-
-          input_type.not_empty "Behaviour element does not have target object input type (input_type) attribute defined, please see #{ name } in behaviour XML files", RuntimeError
-
-          sut_type.not_empty "Behaviour element does not have target object sut type (sut_type) attribute defined, please see #{ name } in behaviour XML files", RuntimeError
+        # behaviours container
+        @behaviours = []
+        
+        # behaviour cache; re-collecting behaviours is not required for similar target objects
+        @behaviours_cache = {}
+            
+      end
 
-          version.not_empty "Behaviour element does not have target object SUT version (version) attribute defined, please see #{ name } in behaviour XML files", RuntimeError
+      # load and parse behaviours files
+      def load_behaviours( path )
 
-          module_node.not_nil "Behaviour does not have implementation module element defined, please see #{ name } in behaviour XML files", RuntimeError
-          
-          # retrieve module name & implementation filename
-          module_attributes = module_node.attributes
-          module_file = module_attributes[ "file" ].to_s # optional
-          module_name = module_attributes[ "name" ].to_s 
+        # behaviour xml files path
+        Dir.glob( File.join( path, '*.xml' ) ){ | filename |
+ 
+          begin
+      
+            # read file contents
+            content = MobyUtil::FileHelper.get_file( filename )  
           
-          module_name.not_empty "Behaviour does not have implementation module name defined, please see #{ name } in behaviour XML files", RuntimeError
-
-          methods_hash = {}
-
-          # create hash of methods
-          node.xpath( 'methods/method' ).each{ | method |
-
-            # retrieve method description & example and store to methods hash
-            methods_hash[ method.attribute( "name" ).to_s.to_sym ] = {
-              :description => method.at_xpath( 'description/text()' ).to_s, 
-              :example     => method.at_xpath( 'example/text()' ).to_s
-            }
-
-          }
-
-          # create and store beahaviour hash
-          @@behaviours << {
-
-            :name => name,
-            :requires => root_attributes[ "plugin" ].to_s.split(";"),
-            :object_type => object_type.split(";"),
-            :input_type => input_type.split(";"),
-            #:sut_type => sut_type.split(";"),
-            :version => version.split(";"),
-            :env => env.split(";"),
-
-            :module => { 
-              :file => module_file, 
-              :name => module_name 
-            },
-
-            :methods => methods_hash
-
-          }
+            # skip when empty file
+            next if content.empty?
+  
+            # parse behaviour xml and process each behaviours element
+            MobyUtil::XML.parse_string( content ).root.xpath( '/behaviours' ).each do | behaviours |
 
+              # retrieve root attributes
+              root_attributes = behaviours.attributes
 
-        }
+              # process each behaviour element
+              behaviours.xpath( './behaviour' ).each do | behaviour |
 
-      }
+                # retrieve behaviour attributes - set default values if not found from element
+                attributes = behaviour.attributes.default_values(
+                  'name'        => '', 
+                  'object_type' => '', 
+                  'input_type'  => '', 
+                  'sut_type'    => '', 
+                  'version'     => '',
+                  'env'         => '*'
+                )
 
-=begin
+                # verify that behaviour attributes are not empty
+                attributes.each_pair do | key, value |                  
 
-      # parse retrieve behaviour definitions
-      document.root.xpath( "/behaviours/behaviour" ).each{ | node |
+                  value.not_empty "behaviour element attribute #{ key.inspect } is not defined or empty", RuntimeError
 
-        # retrieve behaviour attributes & module node
-        attributes = node.attributes
+                end 
 
-        name = attributes[ "name" ].to_s
-        object_type = attributes[ "object_type" ].to_s
-        input_type = attributes[ "input_type" ].to_s
-        sut_type = attributes[ "sut_type" ].to_s
-        version = attributes[ "version" ].to_s
+                # retrieve implementation/module name
+                module_name = behaviour.at_xpath( 'module/@name' ).to_s
 
-        env = ( attributes[ "env" ] || '*' ).to_s 
+                # verify that module name is defined
+                module_name.not_empty "behaviour #{ attributes[ "name" ].inspect } does not have module name defined or is empty", RuntimeError
 
-        module_node = node.xpath( 'module' ).first
-        
-        # verify that all required attributes and nodes are found in behaviour xml node
-        name.not_empty("Behaviour element does not have name (name) attribute defined, please see behaviour XML files", RuntimeError)
-        
-        object_type.not_empty("Behaviour element does not have target object type (object_type) attribute defined, please see #{ name } in behaviour XML files", RuntimeError)
+                # store behaviour 
+                @behaviours << {  
 
-        input_type.not_empty("Behaviour element does not have target object input type (input_type) attribute defined, please see #{ name } in behaviour XML files", RuntimeError)
+                  :index       => @behaviours.count,
+    
+                  :name        => attributes[ 'name'        ],
+                  :object_type => attributes[ 'object_type' ].split(';'),
+                  :input_type  => attributes[ 'input_type'  ].split(';'),
+                  :version     => attributes[ 'version'     ].split(';'),
+                  :env         => attributes[ 'env'         ].split(';'),
+
+                  :requires    => root_attributes[ 'plugin' ].to_s.split(';'),
+
+                  :module      => module_name,
+                  :file        => behaviour.at_xpath( 'module/text()' ).to_s, # optional 
+                  
+                  :methods     => Hash[ 
+                    # collect method details from behaviour 
+                    behaviour.xpath( 'methods/method' ).collect{ | method |                
+                      [ 
+                        method.attribute( 'name' ),
+                        {
+                          :description => method.at_xpath( 'description/text()' ).to_s,
+                          :example     => method.at_xpath( 'example/text()'     ).to_s
+                        }
+                      ]                  
+                    }
+                  ]
+                
+                }
+
+              end # behaviour.each
+
+            end # behaviours.each
+
+          rescue MobyUtil::FileNotFoundError
+
+            raise
+
+          rescue MobyUtil::XML::ParseError
+          
+            raise MobyUtil::XML::ParseError, "Error while parsing behaviours file #{ behaviours[ :filename ] } due to #{ $!.message }"
 
-        sut_type.not_empty("Behaviour element does not have target object sut type (sut_type) attribute defined, please see #{ name } in behaviour XML files", RuntimeError)
+          rescue
 
-        version.not_empty("Behaviour element does not have target object SUT version (version) attribute defined, please see #{ name } in behaviour XML files", RuntimeError)
+            raise RuntimeError, "Error while processing behaviours file #{ filename } due to #{ $!.message }"
 
-        module_node.not_nil("Behaviour does not have implementation module element defined, please see #{ name } in behaviour XML files", RuntimeError)
+          end
         
-        # retrieve module name & implementation filename
-        module_attributes = module_node.attributes
-        module_file = module_attributes[ "file" ].to_s # optional
-        module_name = module_attributes[ "name" ].to_s 
-        
-        #Kernel::raise RuntimeError.new( "Behaviour implementation module name not defined for #{ name } in XML") if module_name.empty?
-        module_name.not_empty("Behaviour does not have implementation module name defined, please see #{ name } in behaviour XML files", RuntimeError)
-
-        methods_hash = {}
-
-        # create hash of methods
-        node.xpath( 'methods/method' ).each{ | method |
-
-          # retrieve method description & example and store to methods hash
-          methods_hash[ method.attribute( "name" ).to_s.to_sym ] = {
-            :description => method.at_xpath( 'description/text()' ).to_s, 
-            :example     => method.at_xpath( 'example/text()' ).to_s
-          }
-
-        }
-
-        # create and store beahaviour hash
-        @@behaviours << {
-
-          :name => name,
-          :requires => root_attributes[ "plugin" ].to_s.split(";"),
-          :object_type => object_type.split(";"),
-          :input_type => input_type.split(";"),
-         #:sut_type => sut_type.split(";"),
-          :version => version.split(";"),
-          :env => env.split(";"),
-
-          :module => { 
-            :file => module_file, 
-            :name => module_name 
-          },
-
-          :methods => methods_hash
-
-        }
-
-      }
+        } # Dir.glob
       
-=end
-
-    }
-
-  end
-
-=begin
-  def get_object_behaviours( rules )
-
-    # calculate hash for behaviour rules / hash value will be used to identify similar objects
-    behaviour_hash = Hash[ rules.select{ | key, value | key != :object  } ].hash
-
-    if @@behaviours_cache.has_key?( behaviour_hash )
-
-      # retrieve behaviour module indexes from cache
-      @@behaviours_cache[ behaviour_hash ]
-
-    else
-
-      rules.default = [ '*' ]
-
-      extended_modules = []
-
-      @@behaviours.each_with_index{ | behaviour, index |
+      end # behaviours
+   
+    end # self
+   
+    # initialize behaviour factory
+    initialize_class
 
-        if ( ( rules[ :name ] == behaviour[ :name ] ) || 
+    # enable hooking for performance measurement & debug logging
+    TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
 
-          ( rules[ :name ] == [ '*' ] && 
-
-          #         ( !( rules[ :sut_type ] & behaviour[ :sut_type ] ).empty? ) && 
-          ( !( rules[ :object_type ] & behaviour[ :object_type ] ).empty? ) &&
-          ( !( rules[ :input_type ] & behaviour[ :input_type ] ).empty? ) &&
-          ( !( rules[ :env ] & behaviour[ :env ] ).empty? ) &&
-          ( !( rules[ :version ] & behaviour[ :version ] ).empty? ) ) )
-
-          # retrieve list of extended modules
-          extended_modules << index
-
-        end
-
-      }
-
-      # store behaviour module indexes to cache
-      @@behaviours_cache[ behaviour_hash ] = extended_modules
-
-    end
-
-  end
-=end
-
-  def get_object_behaviours( rule )
-
-    # calculate hash for behaviour rule / hash value will be used to identify similar objects
-    @@behaviours_cache.fetch( rule.delete_keys( :object ).hash ){ | behaviour_hash |
-
-      rule.default = [ '*' ]
-
-      @@behaviours_cache[ behaviour_hash ] = @@behaviours.each_with_index.collect{ | behaviour, index |
-
-        case rule[ :name ]
-
-          when behaviour[ :name ]
-
-            index
-
-          when [ '*' ]
-
-            index if ( 
-              !( rule[ :object_type ] & behaviour[ :object_type ] ).empty? && 
-              !( rule[ :input_type ] & behaviour[ :input_type ] ).empty? &&
-              !( rule[ :env ] & behaviour[ :env ] ).empty? && 
-              !( rule[ :version ] & behaviour[ :version ] ).empty? 
-            )
-
-        else
-
-          nil
-
-        end
-
-      }.compact
+  end # BehaviourFactory
+  
+end # TDriver
 
-    }
+# backwards compatibility; e.g. if visualizer is too old
+module MobyBase
 
-  end
+  # TODO: document me
+  class BehaviourFactory
 
-  def get_behaviour_from_cache( target, sut_type, object_type, sut_version, input_type )
+    class << self
 
-    if @_behaviour_cache.has_key?( object_type )
+      def instance
 
-      # apply modules to target object
-      @_behaviour_cache[ object_type ].each{ | module_name | target.instance_eval( "self.extend(#{ module_name })" ) }
+        warn_caller "$1:$2 warning: deprecated class MobyBase::BehaviourFactory; please use TDriver::BehaviourFactory instead"
+        
+        TDriver::BehaviourFactory
 
-      # return true
-      true
+      end
 
-    else
-    
-      # return false
-      false
-      
     end
 
-  end
-
-  # enable hooking for performance measurement & debug logging
-  TDriver::Hooking.hook_methods( self ) if defined?( TDriver::Hooking )
-
-  end # BehaviourGenerator
+  end # BehaviourFactory
 
 end # MobyBase