class Build::Files::Composite

Represents a composite list of files from multiple sources.

def +(list)

@returns [Composite] A new composite containing both lists.
@parameter list [List] The list to add.
Combine this composite with another list. 
def +(list)
	if list.kind_of? Composite
		self.class.new(@files + list.files)
	else
		self.class.new(@files + [list])
	end
end

def each

@parameter path [Path] The current file path.
@yields {|path| ...} Each path in all combined lists.
Iterate over all files in the composite list. 
def each
	return to_enum(:each) unless block_given?
	
	@files.each do |files|
		files.each{|path| yield path}
	end
end

def eql?(other)

@returns [Boolean] True if both composites have the same files.
@parameter other [Composite] The other composite to compare.
Check equality with another composite list. 
def eql?(other)
	self.class.eql?(other.class) and @files.eql?(other.files)
end

def freeze

Freeze the composite list and its dependencies. 
def freeze
	self.roots
	
	super
end

def hash

@returns [Integer] The hash value based on files.
Compute the hash value for this composite. 
def hash
	@files.hash
end

def include?(path)

@returns [Boolean] True if any list in the composite includes the path.
@parameter path [Path] The path to check.
Check if the composite includes a specific path. 
def include?(path)
	@files.any? {|list| list.include?(path)}
end

def initialize(files, roots = nil)

@parameter roots [Array(Path) | Nil] The root paths, if known.
@parameter files [Array] The file lists to combine.
Initialize a composite list with multiple file lists. 
def initialize(files, roots = nil)
	@files = []
	
	files.each do |list|
		if list.kind_of? Composite
			@files += list.files
		elsif list.kind_of? List
			@files << list
		else
			# Try to convert into a explicit paths list:
			@files << Paths.new(list)
		end
	end
	
	@files.freeze
	@roots = roots
end

def inspect

@returns [String] A debug string showing the composite structure.
Generate a string representation for debugging. 
def inspect
	"<Composite #{@files.inspect}>"
end

def rebase(root)

@returns [Composite] A new composite with rebased lists.
@parameter root [Path] The new root path.
Rebase all lists in the composite to a new root. 
def rebase(root)
	self.class.new(@files.collect{|list| list.rebase(root)}, [root])
end

def roots

@returns [Array(Path)] The unique root paths.
Get all root paths for all lists in the composite. 
def roots
	@roots ||= @files.collect(&:roots).flatten.uniq
end

def to_paths

@returns [Composite] A new composite with all lists converted to paths.
Convert all lists in the composite to paths. 
def to_paths
	self.class.new(@files.collect(&:to_paths), roots: @roots)
end