 		# collect all files
 		@collect (files)=>
 
-			# process all wild-card dependencies
-			processed = @process_wild_cards files
+			# process all requirements
+			processed = @process_requirements files
 
 			# reorder everything charmingly
 			ordered = @reorder processed

			# finally executes callback, passing the collected buffer
			cb buffer
	
	process_wild_cards: ( buffer ) ->

		# loop through all classes in buffer
		for klass in buffer
			
			# initialize empty arrays for keeping the processed dependencies
			# and the dead index, for after removal
			_dependencies = []
			_dead_indexes = []
			
			# looping through class dependencues
			for dependency, index in klass.dependencies
				
				# continue if dependency is not a wild-card (namespace.*)
				continue if dependency.substr(-1) != "*"

				# otherwise its index to the dead array
				_dead_indexes.push index

				# and find all classes under that namespace
				reg = new RegExp dependency.replace /(\.|\/)/g, "\\$1"
				props = ["classname", "classpath", "filename", "filefolder"]
				found = ArrayUtil.find_all buffer, reg, props, true, true

				# if nothing is found under the given namespace
				if found.length <= 0

			_dead_indexes = _dead_indexes.sort().reverse()

			# remove all dead_indexes from the dependencies array
			file.dependencies.splice dead, 1 for dead in _dead_indexes

			# concat the found dependencies into the file dependencies
			file.dependencies = file.dependencies.concat _dependencies

		# return the files after processing everything
		files
	
	missing = {}
	reorder: (files, cycling = false) ->

		# if cycling is true or @missing is null, initializes empty array
		# for holding missing dependencies
		# 
		# cycling means the redorder method is being called recursively,
		# no other methods call it with cycling = true
		@missing = {} if cycling is false

		# initialized files array, will cache every file as it is read
		initd = []
		
		# looping through all files
		for file, i in files

			# mark file as initialized
			initd.push file

			# if theres no dependencies, go to next file
			continue if file.dependencies.length is 0
			
			# otherwise loop thourgh all file dependencies
			for dependency, index in file.dependencies

				# continue if the dependency was already initialized
				continue if ArrayUtil.has initd, dependency, "filepath"

				# otherwise search by the dependency
				found = ArrayUtil.find files, dependency, "filepath"

				# if it's found
				if found?

					# if there's some circular dependency loop
					if ArrayUtil.has(
						found.item.dependencies,
						file.filepath,
						"filepath"
					)
						# remove it from the dependencies
						file.dependencies.splice index, 1

						# then prints a warning msg and continue
						console.log "WARNING! ".bold.yellow,
							"You have a circular dependcy loop between files",
							"#{dependency.yellow.bold} and",
							"#{file.filepath.yellow.bold}."
						continue
					
					# otherwise if no circular dependency is found, reorder
					# the specific dependency and run reorder recursively until
					# everything is beautiful
					else
						files.splice index, 0, found.item
						files.splice found.index + 1, 1
						files = @reorder files, true
				
				# otherwise if the dependency is not found
				else if @missing[dependency] != true
					# then add it to the @missing hash (so it will be ignored
					# until reordering finishes)
					@missing[dependency] = true
					
					# move it to the end of the dependencies array (avoiding
					# it from being touched again)
					file.dependencies.push dependency
					file.dependencies.splice index, 1

					# ..and finally prints a warning msg
					console.log "WARNING! ".bold.yellow,
						"Dependency #{dependency.yellow.bold} not found",
						"for class #{file.classpath.yellow.bold}."
		
		# after all, return everything in the proper order
		files
	
	merge: (files) ->
		# merge the array and return it
		(file.raw for file in files).join "\n"