298 lines
7.2 KiB
Ruby
Executable File
298 lines
7.2 KiB
Ruby
Executable File
require 'xml'
|
|
require 'pipeline/coding/projbuild/project'
|
|
require 'pipeline/coding/projbuild/xml/include'
|
|
|
|
module Pipeline
|
|
|
|
module ProjBuild
|
|
|
|
class ProjBuildImporter
|
|
|
|
@@log = nil
|
|
|
|
def ProjBuildImporter.log
|
|
|
|
@@log = Log.new( 'projbuildimporter' ) if @@log == nil
|
|
@@log
|
|
end
|
|
|
|
def import( path )
|
|
|
|
if File.exists?(path) == false then
|
|
|
|
ProjBuildImporter.log.debug("couldn't open #{path}")
|
|
return false
|
|
end
|
|
|
|
ProjBuildImporter.log.debug("checking #{path} with internal project loader")
|
|
|
|
parser = XML::Parser.file(path)
|
|
doc = parser.parse
|
|
|
|
if doc.root.name != "rproj" or doc.root["Version"] != "1.00" then
|
|
|
|
ProjBuildImporter.log.debug("#{path} not in the right format")
|
|
return false
|
|
end
|
|
|
|
ProjBuildImporter.log.debug("parsing #{path} with internal project loader")
|
|
|
|
project_node = doc.root.find_first("project")
|
|
project_include = project_node["xinclude"]
|
|
|
|
if project_include != nil
|
|
|
|
ProjBuildImporter.log.debug("yay!")
|
|
|
|
project_node.attributes.get_attribute("xinclude").remove!
|
|
|
|
Pipeline::Globals.instance().in_env do |e|
|
|
|
|
project_include = e.subst(project_include)
|
|
end
|
|
|
|
ProjBuildImporter.log.debug(project_include)
|
|
|
|
xml_include = XMLUtil::Include.instance()
|
|
xml_include.merge_file(project_node,project_include)
|
|
end
|
|
|
|
@curr_project = Info::Project.new(OS::Path.get_basename(path))
|
|
@curr_project.name = project_node.attributes['name']
|
|
@curr_project.guid = project_node.attributes['guid']
|
|
@curr_project.path = project_node.attributes['path']
|
|
# @curr_project.config.root_node.attributes["type"] = project_node.attributes['type']
|
|
|
|
ProjBuildImporter.log.debug("importing tree")
|
|
|
|
import_tree(@curr_project,project_node)
|
|
|
|
return true, @curr_project
|
|
end
|
|
|
|
def import_configurable( configurable, xml_node )
|
|
|
|
xml_config = xml_node.find_first("config")
|
|
configurable.platforms.clear
|
|
|
|
configurable.config.xml_data = xml_config.copy(true) if xml_config != nil
|
|
|
|
xml_node.find("platform").each { |xml_platform|
|
|
|
|
platform_sym = xml_platform.attributes["name"].intern
|
|
|
|
new_platform = Info::Platform.new(platform_sym)
|
|
xml_config = xml_platform.find_first("config")
|
|
new_platform.config.xml_data = xml_config.copy(true) if xml_config != nil
|
|
|
|
configurable.platforms[platform_sym] = new_platform
|
|
|
|
xml_platform.find("target").each { |xml_target|
|
|
|
|
target_name = xml_target.attributes["name"]
|
|
xml_config = xml_target.find_first("config")
|
|
configurable.platforms[platform_sym].get_target(target_name).xml_data = xml_config.copy(true) if xml_config != nil
|
|
}
|
|
}
|
|
end
|
|
|
|
protected
|
|
|
|
def import_tree( filter, xml_node )
|
|
|
|
ProjBuildImporter.log.debug("import node #{filter.name}")
|
|
|
|
import_configurable(filter,xml_node)
|
|
|
|
xml_node.find("filter").each { |xml_filter|
|
|
|
|
new_filter = Info::Filter.new(xml_filter["name"])
|
|
new_filter.path = xml_filter.attributes["path"]
|
|
|
|
import_configurable(new_filter,xml_filter)
|
|
import_tree(new_filter,xml_filter)
|
|
|
|
filter.filters << new_filter
|
|
}
|
|
|
|
xml_node.find("file").each { |xml_file|
|
|
|
|
new_file = Info::File.new(xml_file["path"])
|
|
import_configurable(new_file,xml_file)
|
|
filter.files << new_file
|
|
}
|
|
end
|
|
end
|
|
|
|
class ProjBuildExporter
|
|
|
|
def export( path, project )
|
|
|
|
@path = File.expand_path(path)
|
|
|
|
#we can strip out unrequired configuration here...
|
|
#...i.e. custom build steps that are the same as the wildcard default...
|
|
|
|
project.rationalise
|
|
|
|
#make the root project path relative...
|
|
#project.path = OS::Path::get_directory(path.gsub(project.path,""))
|
|
|
|
doc = XML::Document.new()
|
|
|
|
doc.root = XML::Node.new("rproj")
|
|
doc.root.attributes["Version"] = "1.00"
|
|
export_project(project,doc.root)
|
|
export_solution(doc.root)
|
|
|
|
doc.save(path)
|
|
|
|
true
|
|
end
|
|
|
|
protected
|
|
|
|
def export_config( config, xml_parent )
|
|
|
|
return 0 if (config == nil)
|
|
return 0 if (config.xml_data == nil)
|
|
|
|
xml_parent << config.xml_data.copy(true)
|
|
end
|
|
|
|
def export_configurable( configurable, xml_parent )
|
|
|
|
export_config(configurable.config,xml_parent)
|
|
|
|
return 0 if configurable.platforms == nil
|
|
|
|
configurable.platforms.each { |platform_sym, platform|
|
|
|
|
if platform.targets.size == 0 then
|
|
|
|
next if platform.config == nil
|
|
next if platform.config.is_null
|
|
end
|
|
|
|
xml_platform = XML::Node.new("platform")
|
|
xml_platform.attributes["name"] = platform_sym.to_s
|
|
|
|
export_config(platform.config,xml_platform)
|
|
|
|
platform.targets.each { |target_name, config|
|
|
|
|
xml_config = XML::Node.new("target")
|
|
xml_config.attributes["name"] = target_name
|
|
|
|
export_config(config,xml_config)
|
|
|
|
xml_platform << xml_config
|
|
}
|
|
|
|
xml_parent << xml_platform
|
|
}
|
|
end
|
|
|
|
def export_file( file, xml_parent )
|
|
|
|
xml_node = XML::Node.new("file")
|
|
xml_node.attributes["path"] = OS::Path.make_relative(file.path,OS::Path.remove_filename(@path))
|
|
|
|
export_configurable(file,xml_node)
|
|
|
|
xml_parent << xml_node
|
|
end
|
|
|
|
def add_filter_info( filter, xml_parent )
|
|
|
|
xml_parent.attributes["name"] = filter.name
|
|
xml_parent.attributes["path"] = OS::Path.make_relative(filter.path,OS::Path.remove_filename(@path))
|
|
|
|
export_configurable(filter,xml_parent)
|
|
|
|
filter.filters.each { |child_filter|
|
|
|
|
export_filter(child_filter,xml_parent)
|
|
}
|
|
|
|
filter.files.each { |child_file|
|
|
|
|
export_file(child_file,xml_parent)
|
|
}
|
|
end
|
|
|
|
def export_filter( filter, xml_parent )
|
|
|
|
xml_node = XML::Node.new("filter")
|
|
add_filter_info(filter,xml_node)
|
|
|
|
xml_parent << xml_node
|
|
end
|
|
|
|
def export_project( project, xml_parent )
|
|
|
|
xml_node = XML::Node.new("project")
|
|
xml_node.attributes["guid"] = project.guid
|
|
add_filter_info(project,xml_node)
|
|
|
|
xml_parent << xml_node
|
|
end
|
|
|
|
def export_solution( xml_parent )
|
|
|
|
proj_build = ProjBuildData::instance()
|
|
|
|
xml_node = XML::Node.new("solution")
|
|
|
|
proj_build.sln_platforms.each_pair { |sln_platform, sln_targets|
|
|
|
|
xml_platform = XML::Node.new("platform")
|
|
xml_platform.attributes["name"] = sln_platform
|
|
xml_node << xml_platform
|
|
|
|
sln_targets.each_pair { |sln_target, projectconfigs|
|
|
|
|
xml_target = XML::Node.new("target")
|
|
xml_target.attributes["name"] = sln_target
|
|
xml_platform << xml_target
|
|
|
|
projectconfigs.each_pair { |guid, projectconfig|
|
|
|
|
xml_project = XML::Node.new("projectconfig")
|
|
xml_project.attributes["guid"] = guid
|
|
xml_project.attributes["platform"] = projectconfig.platform.to_s
|
|
xml_project.attributes["target"] = projectconfig.target
|
|
xml_target << xml_project
|
|
}
|
|
}
|
|
}
|
|
|
|
xml_parent << xml_node
|
|
end
|
|
end
|
|
|
|
class ProjBuildGenerator
|
|
@@unity_build_filenames = nil # if true filenames that are created have "_unity" in them.
|
|
def set_unity_build_filenames( set )
|
|
@@unity_build_filenames = set
|
|
end
|
|
|
|
def get_unity_build_filenames( )
|
|
@@unity_build_filenames
|
|
end
|
|
|
|
def export( path, project, options = nil )
|
|
|
|
ProjBuildExporter.new().export(path,project)
|
|
end
|
|
|
|
def import( path, options = nil )
|
|
|
|
ProjBuildImporter.new().import(path)
|
|
end
|
|
end
|
|
|
|
end #module ProjBuild
|
|
|
|
end #module Pipeline
|