public void GetDifficulties()
{
ProjectConfig config = new ProjectConfig();
IList<TaskDifficulty> difficulties;
#region StrDifficulties is null
difficulties = config.GetDifficulties();
Assert.That(difficulties.Count, Is.EqualTo(5));
Assert.That(difficulties.Contains(TaskDifficulty.Easiest));
Assert.That(difficulties.Contains(TaskDifficulty.Easy));
Assert.That(difficulties.Contains(TaskDifficulty.Common));
Assert.That(difficulties.Contains(TaskDifficulty.Hard));
Assert.That(difficulties.Contains(TaskDifficulty.Hardest));
#endregion
#region StrDifficulties not null
config.SetDifficulties(
new List<TaskDifficulty>
{
TaskDifficulty.Easy,
TaskDifficulty.Hard
});
difficulties = config.GetDifficulties();
Assert.That(difficulties.Count, Is.EqualTo(2));
Assert.That(difficulties.Contains(TaskDifficulty.Easy));
Assert.That(difficulties.Contains(TaskDifficulty.Hard));
#endregion
}
public void GetPrioritys()
{
ProjectConfig config = new ProjectConfig();
IList<TaskPriority> prioritys;
#region StrPrioritys is null
prioritys = config.GetPrioritys();
Assert.That(prioritys.Count, Is.EqualTo(5));
Assert.That(prioritys.Contains(TaskPriority.Highest));
Assert.That(prioritys.Contains(TaskPriority.High));
Assert.That(prioritys.Contains(TaskPriority.Common));
Assert.That(prioritys.Contains(TaskPriority.Low));
Assert.That(prioritys.Contains(TaskPriority.Lowest));
#endregion
#region StrPrioritys not null
config.SetPrioritys(
new List<TaskPriority>
{
TaskPriority.Lowest,
TaskPriority.High
});
prioritys = config.GetPrioritys();
Assert.That(prioritys.Count, Is.EqualTo(2));
Assert.That(prioritys.Contains(TaskPriority.Lowest));
Assert.That(prioritys.Contains(TaskPriority.High));
#endregion
}
static ProjectConfig ConvertToPublic(ProjectConfigInternal info)
{
if (info == null)
{
return null;
}
var newInfo = new ProjectConfig();
if (info.AssetsFolder != null)
{
newInfo.AssetsFolder = info.AssetsFolder.ToList();
}
if (info.PluginsFolder != null)
{
newInfo.PluginsFolder = info.PluginsFolder.ToList();
}
if (info.SolutionProjects != null)
{
newInfo.SolutionProjects = info.SolutionProjects.ToList();
}
if (info.SolutionFolders != null)
{
newInfo.SolutionFolders = info.SolutionFolders.ToDictionary(x => x.Key, x => x.Value);
}
return newInfo;
}
public void BuildConfigAndAdd()
{
ProjectConfig config = new ProjectConfig("Debug");
config.Assemblies.Add( Path.DirectorySeparatorChar + "tests" + Path.DirectorySeparatorChar + "bin" + Path.DirectorySeparatorChar + "debug" + Path.DirectorySeparatorChar + "assembly1.dll" );
config.Assemblies.Add( Path.DirectorySeparatorChar + "tests" + Path.DirectorySeparatorChar + "bin" + Path.DirectorySeparatorChar + "debug" + Path.DirectorySeparatorChar + "assembly2.dll" );
configs.Add( config );
Assert.AreEqual( 2, configs["Debug"].Assemblies.Count );
}
public void SetUp()
{
activeConfig = new ProjectConfig( "Debug" );
inactiveConfig = new ProjectConfig("Release");
project = new NUnitProject( TestPath( "/test/myproject.nunit" ) );
project.Configs.Add( activeConfig );
project.Configs.Add(inactiveConfig);
project.IsDirty = false;
project.HasChangesRequiringReload = false;
}
public static ProjectConfig Create([PexAssumeUnderTest] String category, [PexAssumeUnderTest] String dllName)
{
PexAssume.IsTrue(dllName.Length > 0);
PexAssume.IsTrue(category.Equals("Debug") || category.Equals("Release"));
ProjectConfig config1 = new ProjectConfig(category);
config1.BasePath = "bin" + Path.DirectorySeparatorChar + category;
config1.Assemblies.Add(Path.GetFullPath("bin" + Path.DirectorySeparatorChar + category + Path.DirectorySeparatorChar + dllName));
config1.Assemblies.Add(Path.GetFullPath("bin" + Path.DirectorySeparatorChar + category + Path.DirectorySeparatorChar + dllName));
return config1;
}
static ProjectConfigInternal ConvertToInternal(ProjectConfig info)
{
return new ProjectConfigInternal()
{
AssetsFolder = info.AssetsFolder.ToList(),
PluginsFolder = info.PluginsFolder.ToList(),
SolutionProjects = info.SolutionProjects.ToList(),
SolutionFolders = info.SolutionFolders.ToDictionary(x => x.Key, x => x.Value),
};
}
public ProjectConfig GetProjectConfigFromLists()
{
var config = new ProjectConfig();
config.AssetsFolder = _model.AssetItems.ToList();
config.PluginsFolder = _model.PluginItems.ToList();
config.SolutionProjects = _model.VsProjects.ToList();
config.SolutionFolders = _model.VsSolutionFolders.ToDictionary(x => x.Key, x => x.Value);
return config;
}
public void SetDifficulties()
{
ProjectConfig config = new ProjectConfig();
var difficulties = new List<TaskDifficulty> { TaskDifficulty.Easy, TaskDifficulty.Hard };
config.SetDifficulties(difficulties);
var result_difficulties = config.GetDifficulties();
Assert.That(result_difficulties.Count, Is.EqualTo(2));
Assert.That(result_difficulties.Contains(TaskDifficulty.Easy));
Assert.That(result_difficulties.Contains(TaskDifficulty.Hard));
}
static ProjectConfigInternal ConvertToInternal(ProjectConfig info)
{
return new ProjectConfigInternal()
{
ProjectSettingsPath = info.ProjectSettingsPath,
AssetsFolder = info.AssetsFolder.IsEmpty() ? null : info.AssetsFolder.ToList(),
PluginsFolder = info.PluginsFolder.IsEmpty() ? null : info.PluginsFolder.ToList(),
SolutionProjects = info.SolutionProjects.IsEmpty() ? null : info.SolutionProjects.ToList(),
PackageFolders = info.PackageFolders.IsEmpty() ? null : info.PackageFolders.ToList(),
Prebuilt = info.Prebuilt.IsEmpty() ? null : info.Prebuilt.ToList(),
SolutionFolders = info.SolutionFolders.IsEmpty() ? null : info.SolutionFolders.Select(x => new Dictionary<string, string>() { { x.Key, x.Value } } ).ToList(),
};
}
public ProjectConfig GetProjectConfigFromLists()
{
var config = new ProjectConfig();
config.ProjectSettingsPath = _model.ProjectSettingsPath;
config.AssetsFolder.AddRange(_model.AssetItems);
config.PluginsFolder.AddRange(_model.PluginItems);
config.SolutionProjects.AddRange(_model.VsProjects);
config.Prebuilt.AddRange(_model.PrebuiltProjects);
config.SolutionFolders.AddRange(_model.VsSolutionFolders);
config.PackageFolders.AddRange(_model.SavedPackageFolders);
return config;
}
static ProjectConfig ConvertToPublic(ProjectConfigInternal info)
{
if (info == null)
{
return null;
}
var newInfo = new ProjectConfig();
newInfo.ProjectSettingsPath = info.ProjectSettingsPath;
if (info.AssetsFolder != null)
{
newInfo.AssetsFolder.AddRange(info.AssetsFolder.ToList());
}
if (info.PluginsFolder != null)
{
newInfo.PluginsFolder.AddRange(info.PluginsFolder.ToList());
}
if (info.SolutionProjects != null)
{
newInfo.SolutionProjects.AddRange(info.SolutionProjects.ToList());
}
if (info.PackageFolders != null)
{
newInfo.PackageFolders.AddRange(info.PackageFolders.ToList());
}
if (info.Prebuilt != null)
{
newInfo.Prebuilt.AddRange(info.Prebuilt.ToList());
}
if (info.SolutionFolders != null)
{
newInfo.SolutionFolders.AddRange(info.SolutionFolders.Select(x => x.Single()).ToList());
}
return newInfo;
}
public void SaveNormalProject()
{
ProjectConfig config1 = new ProjectConfig( "Debug" );
config1.BasePath = "bin" + Path.DirectorySeparatorChar + "debug";
config1.Assemblies.Add( Path.GetFullPath( "bin" + Path.DirectorySeparatorChar + "debug" + Path.DirectorySeparatorChar + "assembly1.dll" ) );
config1.Assemblies.Add( Path.GetFullPath( "bin" + Path.DirectorySeparatorChar + "debug" + Path.DirectorySeparatorChar + "assembly2.dll" ) );
ProjectConfig config2 = new ProjectConfig( "Release" );
config2.BasePath = "bin" + Path.DirectorySeparatorChar + "release";
config2.Assemblies.Add( Path.GetFullPath( "bin" + Path.DirectorySeparatorChar + "release" + Path.DirectorySeparatorChar + "assembly1.dll" ) );
config2.Assemblies.Add( Path.GetFullPath( "bin" + Path.DirectorySeparatorChar + "release" + Path.DirectorySeparatorChar + "assembly2.dll" ) );
project.Configs.Add( config1 );
project.Configs.Add( config2 );
project.Save( xmlfile );
CheckContents( NUnitProjectXml.NormalProject );
}
public void SaveNormalProjectPUT1([PexAssumeUnderTest]String config1, [PexAssumeUnderTest]String config2, [PexAssumeUnderTest]String _xmlFile)
{
NUnitProject savedProject = NUnitProject.EmptyProject();
PexAssume.IsTrue(config1.Contains("t"));
PexAssume.IsTrue(config2.Contains("t"));
ProjectConfig config = new ProjectConfig(config1);
config.BasePath = "bin" + Path.DirectorySeparatorChar + config1;
config.Assemblies.Add(Path.GetFullPath("bin" + Path.DirectorySeparatorChar + config1 + Path.DirectorySeparatorChar + "assembly1.dll"));
config.Assemblies.Add(Path.GetFullPath("bin" + Path.DirectorySeparatorChar + config1 + Path.DirectorySeparatorChar + "assembly2.dll"));
savedProject.Configs.Add(config);
ProjectConfig _config = new ProjectConfig(config2);
_config.BasePath = "bin" + Path.DirectorySeparatorChar + config2;
_config.Assemblies.Add(Path.GetFullPath("bin" + Path.DirectorySeparatorChar + config2 + Path.DirectorySeparatorChar + "assembly1.dll"));
_config.Assemblies.Add(Path.GetFullPath("bin" + Path.DirectorySeparatorChar + config2 + Path.DirectorySeparatorChar + "assembly2.dll"));
savedProject.Configs.Add(config);
savedProject.Save(_xmlFile, true);
String testOracle = NUnitProjectXml.NormalProject.Replace("Debug", config1);
testOracle = testOracle.Replace("Release", config2);
Console.WriteLine(CreatedProjects.currentProject);
PexAssert.AreEqual(testOracle, CreatedProjects.currentProject);
}
public void GetQualities()
{
ProjectConfig config = new ProjectConfig();
IList<TaskQuality> qualities;
#region StrQualities is null
qualities = config.GetQualities();
Assert.That(qualities.Count, Is.EqualTo(3));
Assert.That(qualities.Contains(TaskQuality.Qualified));
Assert.That(qualities.Contains(TaskQuality.Good));
Assert.That(qualities.Contains(TaskQuality.Perfect));
#endregion
#region StrQualities not null
config.SetQualities(new List<TaskQuality> { TaskQuality.Good });
qualities = config.GetQualities();
Assert.That(qualities.Count, Is.EqualTo(1));
Assert.That(qualities.Contains(TaskQuality.Good));
#endregion
}
public void SetQualities()
{
ProjectConfig config = new ProjectConfig();
IList<TaskQuality> qualities = new List<TaskQuality> { TaskQuality.Good, TaskQuality.Perfect };
config.SetQualities(qualities);
qualities = config.GetQualities();
var result_qualities = config.GetQualities();
Assert.That(result_qualities.Count, Is.EqualTo(2));
Assert.That(result_qualities.Contains(TaskQuality.Good));
Assert.That(result_qualities.Contains(TaskQuality.Perfect));
}
public TaskBuildElement(DocumentInfo Document, ProjectConfig Configuration)
{
m_Document = Document;
m_Configuration = Configuration;
}
public void TestProjectConfig()
{
ProjectConfig project = new ProjectConfig(".\\Project1.mds.tcLS");
Assert.AreEqual(".\\Log", project.LogDir);
Assert.AreEqual("Project1", project.Name);
}
public void Initialize(ProjectConfig config)
{
Tables = new List <TableInfo>();
StagingOptions options = new StagingOptions(config.ProjectName, config.ConnectionString)
{
Provider = ProviderType.PostgreSQL
};
dbContext = new PgDbContext(options);
#region dir
CheckNotNull.NotEmpty(config.ProjectName, nameof(config.ProjectName));
if (config.Mode == GeneralInfo.Db)
{
CheckNotNull.NotEmpty(config.OutputDir, nameof(config.OutputDir));
Config = new GeneralConfig
{
OutputDir = config.OutputDir,
ProjectName = config.ProjectName,
ModelPath = config.OutputDir
};
if (!Directory.Exists(Config.ModelPath))
{
Directory.CreateDirectory(Config.ModelPath);
}
}
#endregion
#region Schemas
string[] filters = new string[this.Filters.Count];
for (int i = 0; i < Filters.Count; i++)
{
filters[i] = $"'{Filters[i]}'";
}
string sql = $@"SELECT schema_name FROM information_schema.schemata WHERE SCHEMA_NAME NOT IN({string.Join(",", filters)}) ORDER BY SCHEMA_NAME; ";
List <string> schemas = new List <string>();
dbContext.Execute.ExecuteDataReader(dr =>
{
schemas.Add(dr[0].ToString());
}, CommandType.Text, sql);
#endregion
#region Tables
foreach (var schema in schemas)
{
string _sqltext = $@"SELECT table_name,'table' as type FROM INFORMATION_SCHEMA.tables WHERE table_schema='{schema}' AND table_type='BASE TABLE'
UNION ALL
SELECT table_name,'view' as type FROM INFORMATION_SCHEMA.views WHERE table_schema = '{schema}'";
dbContext.Execute.ExecuteDataReader(dr =>
{
var table = new TableInfo()
{
Schema = schema,
Name = dr["table_name"].ToString(),
Type = dr["type"].ToString() == "table" ? TableType.Table : TableType.View
};
GetFields(table);
Tables.Add(table);
}, CommandType.Text, _sqltext);
}
#endregion
}
/// <summary>
/// Needed for debugging.
/// </summary>
public static void Empty()
{
ActiveConfig = new ProjectConfig();
}
/// <summary>
/// The environment calls this to set the currently selected objects that the property page should show.
/// </summary>
/// <param name="cObjects">The count of elements in <paramref name="ppunk"/>.</param>
/// <param name="ppunk">An array of <b>IUnknown</b> objects to show in the property page.</param>
/// <remarks>We are supposed to cache these objects until we get another call with
/// <paramref name="cObjects"/> = 0. Also, the environment is supposed to call this before calling
/// <see cref="IPropertyPage.Activate"/>, but don't count on it.</remarks>
void IPropertyPage.SetObjects(uint cObjects, object[] ppunk)
{
if (cObjects == 0)
{
this.ProjectMgr = null;
return;
}
if (ppunk[0] is ProjectConfig)
{
List <ProjectConfig> configs = new List <ProjectConfig>();
for (int i = 0; i < cObjects; i++)
{
ProjectConfig config = (ProjectConfig)ppunk[i];
if (this.ProjectMgr == null)
{
this.ProjectMgr = config.ProjectMgr;
}
configs.Add(config);
}
this.ProjectConfigs = new ReadOnlyCollection <ProjectConfig>(configs);
}
else
if (ppunk[0] is NodeProperties)
{
if (this.ProjectMgr == null)
{
this.ProjectMgr = (ppunk[0] as NodeProperties).Node.ProjectMgr;
}
Dictionary <string, ProjectConfig> configsMap = new Dictionary <string, ProjectConfig>();
for (int i = 0; i < cObjects; i++)
{
NodeProperties property = (NodeProperties)ppunk[i];
IVsCfgProvider provider;
ErrorHandler.ThrowOnFailure(property.Node.ProjectMgr.GetCfgProvider(out provider));
uint[] expected = new uint[1];
ErrorHandler.ThrowOnFailure(provider.GetCfgs(0, null, expected, null));
if (expected[0] > 0)
{
ProjectConfig[] configs = new ProjectConfig[expected[0]];
uint[] actual = new uint[1];
provider.GetCfgs(expected[0], configs, actual, null);
foreach (ProjectConfig config in configs)
{
if (!configsMap.ContainsKey(config.ConfigName))
{
configsMap.Add(config.ConfigName, config);
}
}
}
}
if (configsMap.Count > 0)
{
this.ProjectConfigs = new ReadOnlyCollection <ProjectConfig>(configsMap.Values.ToArray());
}
}
if (!this.IsDisposed && this.ProjectMgr != null)
{
this.BindProperties(this.Controls);
this.IsDirty = false;
}
}
public override string GetTargetDataPath(ProjectConfig target)
{
return(GetTargetDataPath(m_LocalTempCache, target.ProjectName, target.ProjectVersion));
}
/// <summary>
/// Sets the value of the property.
/// </summary>
/// <param name="value">Property value to set.</param>
/// <param name="configs">Optional list of configurations to set the property in;
/// defaults to the project current configuration</param>
/// <remarks>
/// Before calling this method, the caller must ensure that the value is valid according to
/// the <see cref="PropertyValidator"/> class, and that the project file is writable.
/// In most cases the caller should also ensure that the new value is different from the
/// existing value, to avoid dirtying the project file unnecessarily.
/// </remarks>
public void SetValue(string value, IList <ProjectConfig> configs)
{
WixHelperMethods.VerifyNonNullArgument(value, "value");
value = value.Trim();
MSBuild.Project buildProject = this.project.BuildProject;
if (this.PerUser)
{
if (this.project.UserBuildProject == null)
{
this.project.CreateUserBuildProject();
}
buildProject = this.project.UserBuildProject;
}
value = this.Escape(value);
if (this.PerConfig)
{
if (configs == null || configs.Count == 0)
{
configs = new ProjectConfig[] { this.project.CurrentConfig };
}
foreach (ProjectConfig config in configs)
{
bool set = false;
// First see if there's an existing property group that matches our condition
foreach (ProjectPropertyGroupElement propGroup in buildProject.Xml.PropertyGroups)
{
// if there is, set it within that group
if (String.Equals(propGroup.Condition, config.Condition, StringComparison.Ordinal))
{
propGroup.SetProperty(this.propertyName, value);
set = true;
break;
}
}
// If not, add a new property group for the condition and set the property within it
if (!set)
{
ProjectPropertyGroupElement newPropGroup = buildProject.Xml.AddPropertyGroup();
newPropGroup.Condition = config.Condition;
newPropGroup.SetProperty(this.propertyName, value);
set = true;
}
buildProject.ReevaluateIfNecessary();
}
}
else
{
if (this.EndOfProjectFile)
{
List <ProjectPropertyGroupElement> propertyGroupsToDelete = new List <ProjectPropertyGroupElement>();
// First see if there's an existing property group with our property
foreach (ProjectPropertyGroupElement propGroup in buildProject.Xml.PropertyGroups)
{
List <ProjectPropertyElement> propertiesToDelete = new List <ProjectPropertyElement>();
if (!String.IsNullOrEmpty(propGroup.Condition))
{
continue;
}
foreach (ProjectPropertyElement property in propGroup.Properties)
{
// if there is, remove it so the new value is at the end of the file
if (String.IsNullOrEmpty(property.Condition) && String.Equals(property.Name, this.propertyName, StringComparison.OrdinalIgnoreCase))
{
propertiesToDelete.Add(property);
}
}
foreach (ProjectPropertyElement property in propertiesToDelete)
{
propGroup.RemoveChild(property);
}
if (propGroup.Count == 0)
{
propertyGroupsToDelete.Add(propGroup);
}
}
foreach (ProjectPropertyGroupElement propGroup in propertyGroupsToDelete)
{
buildProject.Xml.RemoveChild(propGroup);
}
ProjectPropertyGroupElement newPropGroup = buildProject.Xml.CreatePropertyGroupElement();
buildProject.Xml.AppendChild(newPropGroup);
newPropGroup.SetProperty(this.propertyName, value);
}
else
{
buildProject.SetProperty(this.propertyName, value);
}
}
this.project.InvalidatePropertyCache();
this.project.SetProjectFileDirty(true);
}
/// <summary>
/// 单个检查
/// </summary>
/// <param name="project"></param>
/// <returns></returns>
public bool Validate(ProjectConfig project)
{
return(_builder.Validate(project));
}
bool BuildElement(DocumentInfo Doc, string ConfigSetting, string AdditionalPredefines, bool OutputMessages, out Types.BuildInfo BuildInfo, out Types.ASM.FileInfo FileInfo)
{
BuildInfo = new C64Studio.Types.BuildInfo();
BuildInfo.TargetFile = "";
BuildInfo.TargetType = Types.CompileTargetType.NONE;
FileInfo = null;
Types.ASM.FileInfo combinedFileInfo = null;
try
{
if (Doc.Element != null)
{
Doc.Element.CompileTarget = Types.CompileTargetType.NONE;
Doc.Element.CompileTargetFile = null;
// check dependencies
foreach (var dependency in Doc.Element.ForcedDependency.DependentOnFile)
{
ProjectElement elementDependency = Doc.Project.GetElementByFilename(dependency.Filename);
if (elementDependency == null)
{
Core.AddToOutput("Could not find dependency for " + dependency.Filename + System.Environment.NewLine);
return(false);
}
Types.ASM.FileInfo dependencyFileInfo = null;
// skip building if not required
if (!Core.Compiling.NeedsRebuild(elementDependency.DocumentInfo, ConfigSetting))
{
Core.AddToOutput("Dependency " + dependency.Filename + " is current for config " + ConfigSetting + System.Environment.NewLine);
if ((Doc.Type == ProjectElement.ElementType.ASM_SOURCE) ||
(Doc.Type == ProjectElement.ElementType.BASIC_SOURCE))
{
dependencyFileInfo = elementDependency.DocumentInfo.ASMFileInfo;
//Debug.Log( "Doc " + Doc.Text + " receives " + dependencyFileInfo.Labels.Count + " dependency labels from dependency " + dependency.Filename );
}
}
else
{
Types.BuildInfo tempInfo = new C64Studio.Types.BuildInfo();
if (!BuildElement(elementDependency.DocumentInfo, ConfigSetting, null, false, out tempInfo, out dependencyFileInfo))
{
return(false);
}
}
// include symbols from dependency
if (dependency.IncludeSymbols)
{
if (combinedFileInfo == null)
{
combinedFileInfo = new C64Studio.Types.ASM.FileInfo();
}
// merge label info
if (dependencyFileInfo != null)
{
foreach (var entry in dependencyFileInfo.Labels)
{
if (!combinedFileInfo.Labels.ContainsKey(entry.Key))
{
combinedFileInfo.Labels.Add(entry.Key, entry.Value);
}
}
//Debug.Log( "Doc " + Doc.Text + " receives " + dependencyFileInfo.Labels.Count + " dependency labels from dependency " + dependency.Filename );
}
}
}
}
if (!Doc.Compilable)
{
// not buildable
// TODO - Autoexport?
return(true);
}
ToolInfo tool = Core.DetermineTool(Doc, false);
ProjectElement.PerConfigSettings configSetting = null;
Parser.ParserBase parser = Core.DetermineParser(Doc);
if (Doc.Element != null)
{
if (!Doc.Element.Settings.ContainsKey(ConfigSetting))
{
Doc.Element.Settings.Add(ConfigSetting, new ProjectElement.PerConfigSettings());
}
configSetting = Doc.Element.Settings[ConfigSetting];
if (!string.IsNullOrEmpty(configSetting.PreBuild))
{
Core.AddToOutput("Running pre build step on " + Doc.Element.Name + System.Environment.NewLine);
if (!Core.MainForm.RunCommand(Doc, "pre build", configSetting.PreBuild))
{
return(false);
}
}
if (configSetting.PreBuildChain.Active)
{
if (!BuildChain(configSetting.PreBuildChain, "pre build chain", OutputMessages))
{
return(false);
}
}
Core.AddToOutput("Running build on " + Doc.Element.Name + " with configuration " + ConfigSetting + System.Environment.NewLine);
}
else
{
Core.AddToOutput("Running build on " + Doc.DocumentFilename + System.Environment.NewLine);
}
// include previous symbols
if (parser is Parser.ASMFileParser)
{
((Parser.ASMFileParser)parser).InitialFileInfo = combinedFileInfo;
if (combinedFileInfo != null)
{
//Debug.Log( "Doc " + Doc.Text + " receives " + combinedFileInfo.Labels.Count + " initial labels" );
}
if (!string.IsNullOrEmpty(AdditionalPredefines))
{
((Parser.ASMFileParser)parser).ParseAndAddPreDefines(AdditionalPredefines);
}
}
else if (parser is Parser.BasicFileParser)
{
// BASIC may receive symbols from assembly
((Parser.BasicFileParser)parser).InitialFileInfo = combinedFileInfo;
if (combinedFileInfo != null)
{
//Debug.Log( "Doc " + Doc.Text + " receives " + combinedFileInfo.Labels.Count + " initial labels" );
}
Doc.ASMFileInfo = combinedFileInfo;
}
if ((configSetting != null) &&
(!string.IsNullOrEmpty(configSetting.CustomBuild)))
{
Core.AddToOutput("Running custom build step on " + Doc.Element.Name + " with configuration " + ConfigSetting + System.Environment.NewLine);
if (!Core.MainForm.RunCommand(Doc, "custom build", configSetting.CustomBuild))
{
return(false);
}
}
else
{
ProjectConfig config = null;
if (Doc.Project != null)
{
config = Doc.Project.Settings.Configs[ConfigSetting];
}
int startAddress = -1;
if ((Doc.Type == ProjectElement.ElementType.BASIC_SOURCE) &&
(Doc.BaseDoc != null))
{
// BASIC files bring a start address
startAddress = ((SourceBasicEx)Doc.BaseDoc).StartAddress;
}
if ((!Core.MainForm.ParseFile(parser, Doc, config, OutputMessages, CreatePreProcessedFile)) ||
(!parser.Assemble(new C64Studio.Parser.CompileConfig()
{
TargetType = Core.DetermineTargetType(Doc, parser),
OutputFile = Core.DetermineTargetFilename(Doc, parser),
AutoTruncateLiteralValues = Core.Settings.ASMAutoTruncateLiteralValues,
StartAddress = startAddress
})) ||
(parser.Errors > 0))
{
Core.MainForm.AddOutputMessages(parser);
Core.AddToOutput("Build failed, " + parser.Warnings.ToString() + " warnings, " + parser.Errors.ToString() + " errors encountered" + System.Environment.NewLine);
// always show messages if we fail!
//if ( OutputMessages )
{
Core.Navigating.UpdateFromMessages(parser.Messages,
(parser is Parser.ASMFileParser) ? ((Parser.ASMFileParser)parser).ASMFileInfo : null,
Doc.Project);
Core.MainForm.m_CompileResult.UpdateFromMessages(parser, Doc.Project);
}
Core.ShowDocument(Core.MainForm.m_CompileResult);
Core.MainForm.AppState = Types.StudioState.NORMAL;
if (Core.Settings.PlaySoundOnBuildFailure)
{
System.Media.SystemSounds.Exclamation.Play();
}
return(false);
}
Core.MainForm.AddOutputMessages(parser);
var compileTarget = Core.DetermineTargetType(Doc, parser);
string compileTargetFile = Core.DetermineTargetFilename(Doc, parser);
if (Doc.Element != null)
{
Doc.Element.CompileTargetFile = compileTargetFile;
}
if (compileTargetFile == null)
{
if (parser is Parser.ASMFileParser)
{
parser.AddError(-1, Types.ErrorCode.E0001_NO_OUTPUT_FILENAME, "No output filename was given, missing element setting or !to <Filename>,<FileType> macro?");
}
else
{
parser.AddError(-1, Types.ErrorCode.E0001_NO_OUTPUT_FILENAME, "No output filename was given, missing element setting");
}
if (OutputMessages)
{
Core.Navigating.UpdateFromMessages(parser.Messages,
(parser is Parser.ASMFileParser) ? ((Parser.ASMFileParser)parser).ASMFileInfo : null,
Doc.Project);
Core.MainForm.m_CompileResult.UpdateFromMessages(parser, Doc.Project);
}
Core.ShowDocument(Core.MainForm.m_CompileResult);
Core.MainForm.AppState = Types.StudioState.NORMAL;
if (Core.Settings.PlaySoundOnBuildFailure)
{
System.Media.SystemSounds.Exclamation.Play();
}
return(false);
}
BuildInfo.TargetFile = compileTargetFile;
BuildInfo.TargetType = compileTarget;
if (parser.Warnings > 0)
{
if (OutputMessages)
{
Core.Navigating.UpdateFromMessages(parser.Messages,
(parser is Parser.ASMFileParser) ? ((Parser.ASMFileParser)parser).ASMFileInfo : null,
Doc.Project);
Core.MainForm.m_CompileResult.UpdateFromMessages(parser, Doc.Project);
}
Core.ShowDocument(Core.MainForm.m_CompileResult);
}
}
if (string.IsNullOrEmpty(BuildInfo.TargetFile))
{
Core.AddToOutput("No target file name specified" + System.Environment.NewLine);
Core.MainForm.AppState = Types.StudioState.NORMAL;
if (Core.Settings.PlaySoundOnBuildFailure)
{
System.Media.SystemSounds.Exclamation.Play();
}
return(false);
}
// write output if applicable
if ((parser.AssembledOutput != null) &&
(parser.AssembledOutput.Assembly != null))
{
try
{
System.IO.File.WriteAllBytes(BuildInfo.TargetFile, parser.AssembledOutput.Assembly.Data());
}
catch (System.Exception ex)
{
Core.AddToOutput("Build failed, Could not create output file " + parser.CompileTargetFile + System.Environment.NewLine);
Core.AddToOutput(ex.ToString() + System.Environment.NewLine);
Core.MainForm.AppState = Types.StudioState.NORMAL;
if (Core.Settings.PlaySoundOnBuildFailure)
{
System.Media.SystemSounds.Exclamation.Play();
}
return(false);
}
Core.AddToOutput("Build successful, " + parser.Warnings.ToString() + " warnings, 0 errors encountered" + System.Environment.NewLine);
Core.AddToOutput("Start address $" + parser.AssembledOutput.OriginalAssemblyStartAddress.ToString("X4")
+ " to $" + (parser.AssembledOutput.OriginalAssemblyStartAddress + parser.AssembledOutput.OriginalAssemblySize - 1).ToString("X4")
+ ", size " + parser.AssembledOutput.OriginalAssemblySize + " bytes" + System.Environment.NewLine);
Core.AddToOutput("Compiled to file " + BuildInfo.TargetFile + ", " + parser.AssembledOutput.Assembly.Length + " bytes" + System.Environment.NewLine);
//Debug.Log( "File " + Doc.DocumentFilename + " was rebuilt for config " + ConfigSetting + " this round" );
}
if ((configSetting != null) &&
(configSetting.PostBuildChain.Active))
{
if (!BuildChain(configSetting.PostBuildChain, "post build chain", OutputMessages))
{
return(false);
}
}
if ((configSetting != null) &&
(!string.IsNullOrEmpty(configSetting.PostBuild)))
{
Core.ShowDocument(Core.MainForm.m_Output);
Core.AddToOutput("Running post build step on " + Doc.Element.Name + System.Environment.NewLine);
if (!Core.MainForm.RunCommand(Doc, "post build", configSetting.PostBuild))
{
return(false);
}
}
Doc.HasBeenSuccessfullyBuilt = true;
if (parser is Parser.ASMFileParser)
{
FileInfo = ((Parser.ASMFileParser)parser).ASMFileInfo;
// update symbols in main asm file
Doc.SetASMFileInfo(FileInfo, parser.KnownTokens(), parser.KnownTokenInfo());
//Debug.Log( "Doc " + Doc.Text + " gets " + ( (SourceASM)Doc ).ASMFileInfo.Labels.Count + " labels" );
}
if (FileInfo != null)
{
if (!string.IsNullOrEmpty(FileInfo.LabelDumpFile))
{
Core.MainForm.DumpLabelFile(FileInfo);
}
}
Core.Compiling.m_RebuiltFiles.Add(Doc.DocumentFilename);
return(true);
}
catch (Exception ex)
{
Core.AddToOutput("An error occurred during building an element\r\n" + ex.ToString());
return(false);
}
}
private static ConversionEvent BuildConversionEvent(string eventName, ProjectConfig projectConfig)
{
return(UserEventFactory.CreateConversionEvent(projectConfig, eventName, TestUserId,
new UserAttributes(), new EventTags()));
}
public override string GetTargetDataUri(ProjectConfig target)
{
return(Path.Combine(GetTargetDataPath(target), s_ModuleData));
}
void PopulateModelFromConfig(ProjectConfig config)
{
_model.ProjectSettingsPath = config.ProjectSettingsPath;
_model.ClearPluginItems();
foreach (var name in config.PluginsFolder)
{
_model.AddPluginItem(name);
}
_model.ClearAssetItems();
foreach (var name in config.AssetsFolder)
{
_model.AddAssetItem(name);
}
_model.ClearSolutionProjects();
foreach (var name in config.SolutionProjects)
{
_model.AddVsProject(name);
}
_model.ClearPrebuiltProjects();
foreach (var name in config.Prebuilt)
{
_model.AddPrebuilt(name);
}
_model.ClearSolutionFolders();
foreach (var pair in config.SolutionFolders)
{
_model.AddSolutionFolder(pair.Key, pair.Value);
}
_model.ClearSavedPackageFolders();
foreach (var pair in config.PackageFolders)
{
_model.AddSavedPackageFolder(pair);
}
}
private string GetRemoteTargetDataUri(ProjectConfig target)
{
return(Path.Combine(GetRemoteTargetDataPath(target), s_ModuleData));
}
public static void ProcessFile(ProjectConfig project)
{
var sw = Stopwatch.StartNew();
while (true)
{
try
{
var pyxelPath = project.GetPyxelPath();
Console.WriteLine($"Processing { pyxelPath}");
if (File.Exists(pyxelPath))
{
using (var stream = File.Open(pyxelPath, FileMode.Open, FileAccess.Read, FileShare.Read))
{
using (var doc = new PyxelParser.Document(stream))
{
var meta = doc.MetaData.Value;
bool sheetFinder(KeyValuePair <int, PyxelParser.Layer> l) => l.Value.Name.Trim().Equals("Sheet", StringComparison.InvariantCultureIgnoreCase);
if (!meta.Canvas.Layers.Any(sheetFinder))
{
throw new KeyNotFoundException("Could not find a layer named 'Sheet'");
}
var sheetLayer = meta.Canvas.Layers.Single(sheetFinder);
var columns = meta.Canvas.GetColumns();
var rows = meta.Canvas.GetRows();
using (var img = doc.GetImages(entry => Image.FromStream(entry.Stream)).Single(i => i.Path == $"layer{sheetLayer.Key}.png").Value)
{
Directory.CreateDirectory(Path.GetDirectoryName(project.GetTilesetImagePath()));
var imgPath = project.GetTilesetImagePath();
SaveSheet(project.Tileset, meta, columns, rows, img, imgPath);
}
var ts = new Tiled.Tileset()
{
firstgid = 1,
Columns = columns,
ImagePath = project.Tileset.ImageFile,
imagewidth = meta.Canvas.Width,
imageheight = meta.Canvas.Height,
margin = 0,
name = project.Tileset.Name,
spacing = project.Tileset.Spacing,
TileCount = columns * rows,
tileheight = meta.Canvas.TileHeight,
tilewidth = meta.Canvas.TileWidth,
transparentcolor = null
};
Directory.CreateDirectory(Path.GetDirectoryName(project.GetTilesetJsonPath()));
File.WriteAllText(project.GetTilesetJsonPath(), JsonConvert.SerializeObject(ts, Formatting.Indented));
}
}
}
break;
}
catch (IOException)
{
System.Threading.Thread.Sleep(10);
if (sw.Elapsed > TimeSpan.FromSeconds(3))
{
throw;
}
}
}
}
private string GetRemoteTargetInfoUri(ProjectConfig target)
{
return(Path.Combine(GetRemoteModulePackagePath(target), target.ProjectVersion, s_ModuleTarget));
}
internal static Project create(User user, string name, string description, ProjectConfig config, Project parent)
{
Project project = new Project { Name = name, Description = description, Config = config, Parent = parent };
user.Create(project);
return project;
}
public void Initialize()
{
LoggerMock = new Mock <ILogger>();
DecisionReasonsObj = new DecisionReasons();
Config = DatafileProjectConfig.Create(TestData.Datafile, LoggerMock.Object, new ErrorHandler.NoOpErrorHandler());
}
public void CodeFirst(ProjectConfig config)
{
Initialize(config);
StringBuilder sb = new StringBuilder();
List <TableInfo> tables = new List <TableInfo>();
var fileName = config.ProjectName + ".dll";
var dir = System.IO.Directory.GetCurrentDirectory();
var providerFile = System.IO.Directory.GetFiles(dir, fileName, SearchOption.AllDirectories).FirstOrDefault();
if (string.IsNullOrEmpty(providerFile))
{
throw new FileNotFoundException($"在 {dir} 搜索不到文件 {fileName}");
}
var types = Assembly.LoadFrom(providerFile).GetTypes();
List <TableInfo> entitys = new List <TableInfo>();
foreach (var t in types)
{
var tableAttribute = t.GetCustomAttribute <TableAttribute>();
if (tableAttribute == null)
{
continue;
}
entitys.Add(new TableInfo
{
Name = tableAttribute.Name,
Schema = tableAttribute.Schema,
EntityType = t
});
}
foreach (var ent in entitys)
{
SerializeField(ent, ent.EntityType);
var table = Tables.Where(f => f.Schema == ent.Schema && f.Name == ent.Name).FirstOrDefault();
if (table == null) // CREATE
{
DumpTable(ent, ref sb);
}
else // ALTER
{
DumpAlter(ent, table, ref sb);
}
}
// 删除实体
foreach (var table in Tables)
{
if (entitys.Where(f => f.Schema == table.Schema && f.Name == table.Name).FirstOrDefault() == null)
{
sb.AppendLine($"DROP TABLE {MyStagingUtils.GetTableName(table, ProviderType.PostgreSQL)};");
}
}
var sql = sb.ToString();
if (string.IsNullOrEmpty(sql))
{
Console.WriteLine("数据模型没有可执行的更改.");
}
else
{
Console.WriteLine("------------------SQL------------------");
Console.WriteLine(sql);
Console.WriteLine("------------------SQL END------------------");
dbContext.Execute.ExecuteNonQuery(CommandType.Text, sql);
}
}
public void Cleanup()
{
LoggerMock = null;
Config = null;
}
/// <summary>
/// Constructor for IVSOutputGroup2 implementation
/// </summary>
/// <param name="outputName">Name of the output group. See VS_OUTPUTGROUP_CNAME_Build in vsshell.idl for the list of standard values</param>
/// <param name="msBuildTargetName">MSBuild target name</param>
/// <param name="projectManager">Project that produce this output</param>
/// <param name="configuration">Configuration that produce this output</param>
internal OutputGroup(string outputName, string msBuildTargetName, ProjectNode projectManager, ProjectConfig configuration)
{
if (outputName == null)
{
throw new ArgumentNullException("outputName");
}
if (msBuildTargetName == null)
{
throw new ArgumentNullException("outputName");
}
if (projectManager == null)
{
throw new ArgumentNullException("projectManager");
}
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
name = outputName;
targetName = msBuildTargetName;
project = projectManager;
projectCfg = configuration;
}
static int Main(string[] args)
{
var configReader = new ArgumentEvaluator();
var config = configReader.CheckParams(args, out string additionalDefines, out bool showNoWarnings, out List <string> WarningsToIgnore);
if (config == null)
{
return(1);
}
config.Assembler = C64Studio.Types.AssemblerType.C64_STUDIO;
var parser = new ASMFileParser();
var projectConfig = new ProjectConfig();
// TODO - add defines if given
string fullPath = System.IO.Path.GetFullPath(config.InputFile);
if (string.IsNullOrEmpty(config.OutputFile))
{
// provide a default
config.OutputFile = GR.Path.RenameExtension(config.InputFile, ".prg");
config.TargetType = C64Studio.Types.CompileTargetType.PRG;
}
bool result = parser.ParseFile(fullPath, "", projectConfig, config, additionalDefines);
if (!result)
{
System.Console.WriteLine("Parsing the file failed:");
DisplayOutput(parser, WarningsToIgnore, showNoWarnings);
return(1);
}
// default to plain
C64Studio.Types.CompileTargetType compileTargetType = C64Studio.Types.CompileTargetType.PLAIN;
// command line given target type overrides everything
if (config.TargetType != C64Studio.Types.CompileTargetType.NONE)
{
compileTargetType = config.TargetType;
}
else if (parser.CompileTarget != C64Studio.Types.CompileTargetType.NONE)
{
compileTargetType = parser.CompileTarget;
}
config.TargetType = compileTargetType;
if (!parser.Assemble(config))
{
System.Console.WriteLine("Assembling the output failed");
DisplayOutput(parser, WarningsToIgnore, showNoWarnings);
return(1);
}
DisplayOutput(parser, WarningsToIgnore, showNoWarnings);
if (!GR.IO.File.WriteAllBytes(config.OutputFile, parser.AssembledOutput.Assembly))
{
System.Console.WriteLine("Failed to write output file");
return(1);
}
if (!string.IsNullOrEmpty(config.LabelDumpFile))
{
DumpLabelFile(parser.ASMFileInfo);
}
return(0);
}
public ConfigEvaluatorTestsBase()
{
this.configEvaluator = new RolloutEvaluator(logger, new ConfigDeserializer(logger, JsonSerializer.Create()));
this.config = new ProjectConfig(this.GetSampleJson(), DateTime.UtcNow, null);
}
/// <summary>
/// The environment calls this to set the currently selected objects that the property page should show.
/// </summary>
/// <param name="count">The count of elements in <paramref name="punk"/>.</param>
/// <param name="punk">An array of <b>IUnknown</b> objects to show in the property page.</param>
/// <remarks>
/// We are supposed to cache these objects until we get another call with <paramref name="count"/> = 0.
/// Also, the environment is supposed to call this before calling <see cref="IPropertyPage2.Activate"/>,
/// but like all things when interacting with Visual Studio, don't trust that and code defensively.
/// </remarks>
void IPropertyPage.SetObjects(uint count, object[] punk)
{
if (count == 0)
{
if (this.project != null)
{
this.project.OutputTypeChanged -= this.HandleOutputTypeChanged;
this.project = null;
}
return;
}
if (punk[0] is ProjectConfig)
{
List <ProjectConfig> configs = new List <ProjectConfig>();
for (int i = 0; i < count; i++)
{
ProjectConfig config = (ProjectConfig)punk[i];
if (this.project == null)
{
this.project = config.ProjectMgr as WixProjectNode;
this.project.OutputTypeChanged += this.HandleOutputTypeChanged;
}
configs.Add(config);
}
this.projectConfigs = configs.ToArray();
}
else if (punk[0] is NodeProperties)
{
if (this.project == null)
{
this.project = (punk[0] as NodeProperties).Node.ProjectMgr as WixProjectNode;
this.project.OutputTypeChanged += this.HandleOutputTypeChanged;
}
Dictionary <string, ProjectConfig> configsMap = new Dictionary <string, ProjectConfig>();
for (int i = 0; i < count; i++)
{
NodeProperties property = (NodeProperties)punk[i];
IVsCfgProvider provider;
ErrorHandler.ThrowOnFailure(property.Node.ProjectMgr.GetCfgProvider(out provider));
uint[] expected = new uint[1];
ErrorHandler.ThrowOnFailure(provider.GetCfgs(0, null, expected, null));
if (expected[0] > 0)
{
ProjectConfig[] configs = new ProjectConfig[expected[0]];
uint[] actual = new uint[1];
int hr = provider.GetCfgs(expected[0], configs, actual, null);
if (hr != 0)
{
Marshal.ThrowExceptionForHR(hr);
}
foreach (ProjectConfig config in configs)
{
if (!configsMap.ContainsKey(config.ConfigName))
{
configsMap.Add(config.ConfigName, config);
}
}
}
}
if (configsMap.Count > 0)
{
if (this.projectConfigs == null)
{
this.projectConfigs = new ProjectConfig[configsMap.Keys.Count];
}
configsMap.Values.CopyTo(this.projectConfigs, 0);
}
}
if (this.active && this.project != null)
{
this.PropertyPagePanel.BindProperties();
this.IsDirty = false;
}
}
public virtual void SetObjects(uint count, object[] punk)
{
if(count > 0)
{
if(punk[0] is ProjectConfig)
{
ArrayList configs = new ArrayList();
for(int i = 0; i < count; i++)
{
ProjectConfig config = (ProjectConfig)punk[i];
if(this.project == null)
{
this.project = config.ProjectMgr;
}
configs.Add(config);
}
this.projectConfigs = (ProjectConfig[])configs.ToArray(typeof(ProjectConfig));
}
else if(punk[0] is NodeProperties)
{
if(this.project == null)
{
this.project = (punk[0] as NodeProperties).Node.ProjectMgr;
}
System.Collections.Generic.Dictionary<string, ProjectConfig> configsMap = new System.Collections.Generic.Dictionary<string, ProjectConfig>();
for(int i = 0; i < count; i++)
{
NodeProperties property = (NodeProperties)punk[i];
IVsCfgProvider provider;
ErrorHandler.ThrowOnFailure(property.Node.ProjectMgr.GetCfgProvider(out provider));
uint[] expected = new uint[1];
ErrorHandler.ThrowOnFailure(provider.GetCfgs(0, null, expected, null));
if(expected[0] > 0)
{
ProjectConfig[] configs = new ProjectConfig[expected[0]];
uint[] actual = new uint[1];
ErrorHandler.ThrowOnFailure(provider.GetCfgs(expected[0], configs, actual, null));
foreach(ProjectConfig config in configs)
{
if(!configsMap.ContainsKey(config.ConfigName))
{
configsMap.Add(config.ConfigName, config);
}
}
}
}
if(configsMap.Count > 0)
{
if(this.projectConfigs == null)
{
this.projectConfigs = new ProjectConfig[configsMap.Keys.Count];
}
configsMap.Values.CopyTo(this.projectConfigs, 0);
}
}
}
else
{
this.project = null;
}
if(this.active && this.project != null)
{
UpdateObjects();
}
}
private string GetRemoteModulePackagePath(ProjectConfig package)
{
return(Path.Combine(ModuleRoot.OriginalString, s_ModulePath, package.ProjectName));
}
public void SetUp()
{
config = new ProjectConfig( "Debug" );
project = new NUnitProject( TestPath( "/test/myproject.nunit" ) );
project.Configs.Add( config );
}
protected virtual void Initialize(string connectionString = null)
{
if (string.IsNullOrWhiteSpace(connectionString))
connectionString = GetConfiguredConnectionString();
using (var db = new BuildVersioningDataContext(connectionString))
{
DeleteTestProjectAndTestProjectConfig(db);
var project =
new Project
{
Name = TestProjectName,
BuildNumber = 0,
DateBuildNumberUpdated = DateTime.Now
};
db.Projects.Add(project);
db.SaveChanges();
var projectConfig =
new ProjectConfig
{
ProjectId = project.Id,
Name = TestProjectConfigName,
GeneratedBuildNumberPosition = 3,
GeneratedVersionPart1 = 1,
GeneratedVersionPart2 = 0,
GeneratedVersionPart3 = 0,
GeneratedVersionPart4 = 0,
ProductVersionPart1 = 1,
ProductVersionPart2 = 0,
ProductVersionPart3 = 0,
ProductVersionPart4 = 0,
ReleaseType = ReleaseType.PreRelease
};
db.ProjectConfigs.Add(projectConfig);
db.SaveChanges();
}
}
public static void Run(IConsole console, ProjectFile pf, ProjectConfig cfg, bool verbose)
{
try
{
pf.LoadAll();
}
catch (Exception e)
{
console.Error.WriteLine($"Failed to load project: {e}");
return;
}
List <Command> commands = new List <Command>()
{
new Command(new[] { "exit", "quit" },
"Exits this shell.",
"[exit|quit]",
args =>
{
// TODO prompt to save anything? maybe not?
return(Command.CommandResult.Quit);
}),
new Command(new[] { "reload" },
"Reloads the project as it currently is on disk.",
"reload <optional:data>",
args =>
{
if (!ReloadProject(console, ref pf, cfg, verbose, (args.Length == 2 && args[1] == "data")))
{
return(Command.CommandResult.Quit);
}
return(Command.CommandResult.None);
}),
new Command(new[] { "add" },
"Adds an asset from game data to the project.",
"add <asset_type> <asset_names>",
args =>
{
if (args.Length != 3)
{
return(Command.CommandResult.InvalidSyntax);
}
switch (args[1].ToLowerInvariant())
{
case "path":
case "paths":
AddAsset(console, args[2], pf.Paths, pf);
break;
case "sprite":
case "sprites":
AddAsset(console, args[2], pf.Sprites, pf);
break;
case "sound":
case "sounds":
AddAsset(console, args[2], pf.Sounds, pf);
break;
case "object":
case "objects":
AddAsset(console, args[2], pf.Objects, pf);
break;
case "background":
case "backgrounds":
AddAsset(console, args[2], pf.Backgrounds, pf);
break;
case "font":
case "fonts":
AddAsset(console, args[2], pf.Fonts, pf);
break;
case "room":
case "rooms":
AddAsset(console, args[2], pf.Rooms, pf);
break;
default:
return(Command.CommandResult.InvalidSyntax);
}
return(Command.CommandResult.None);
}),
new Command(new[] { "apply" },
"Applies the project to the input data file, resulting in output.",
"apply",
args =>
{
try
{
pf.LoadAll();
using FileStream fs = new FileStream(Path.Combine(cfg.OutputDirectory, pf.DataHandle.Filename), FileMode.Create);
using GMDataWriter writer = new GMDataWriter(pf.DataHandle, fs, fs.Name, pf.DataHandle.Length);
console.Output.WriteLine("Converting to data...");
pf.ConvertToData();
console.Output.WriteLine("Writing main data file...");
writer.Write();
writer.Flush();
foreach (GMWarning w in writer.Warnings)
{
console.Output.WriteLine($"[WARN: {w.Level}] {w.Message}"); // todo formatting
}
}
catch (Exception e)
{
console.Error.WriteLine($"Failed to apply project: {e}");
}
if (!ReloadProject(console, ref pf, cfg, verbose))
{
return(Command.CommandResult.Quit);
}
return(Command.CommandResult.None);
})
};
int helpLength = commands.Max(c => c.Usage.Length) + 1;
console.Error.WriteLine();
console.Error.WriteLine("DogScepter project shell");
bool running = true;
while (running)
{
console.Output.Write("> ");
string command = console.Input.ReadLine();
string[] args = command.Split(' ', StringSplitOptions.RemoveEmptyEntries);
if (args.Length >= 1)
{
string name = args[0].ToLowerInvariant();
if (name == "help")
{
if (args.Length == 2)
{
string helpName = args[1].ToLowerInvariant();
Command cmd = commands.Find(c => c.Names.Contains(helpName));
if (cmd != null)
{
console.Output.WriteLine(cmd.Description);
console.Output.WriteLine(cmd.Usage);
console.Output.WriteLine();
continue;
}
}
foreach (var cmd in commands)
{
console.Output.WriteLine(cmd.Usage + new string(' ', helpLength - cmd.Usage.Length) +
" | " + cmd.Description);
}
}
else
{
Command cmd = commands.Find(c => c.Names.Contains(name));
if (cmd == null)
{
console.Error.WriteLine($"Unknown command \"{args[0]}\"");
}
else
{
switch (cmd.Function(args))
{
case Command.CommandResult.InvalidSyntax:
console.Error.WriteLine("Invalid syntax; proper usage:");
console.Error.WriteLine(" " + cmd.Usage);
break;
case Command.CommandResult.Quit:
running = false;
break;
}
}
}
}
console.Output.WriteLine();
}
}
}
public ProjectConfigProperties(ProjectConfig projectConfig)
{
this.projectConfig = projectConfig;
}
/// <summary>
/// Load a non-C++ project in the MsBuild format introduced with VS2005
/// </summary>
private void LoadMSBuildProject()
{
XmlNamespaceManager namespaceManager = new XmlNamespaceManager(_doc.NameTable);
namespaceManager.AddNamespace("msbuild", "http://schemas.microsoft.com/developer/msbuild/2003");
XmlNodeList nodes = _doc.SelectNodes("/msbuild:Project/msbuild:PropertyGroup", namespaceManager);
if (nodes == null)
{
return;
}
MsBuildDocument = _doc;
XmlElement assemblyNameElement = (XmlElement)_doc.SelectSingleNode("/msbuild:Project/msbuild:PropertyGroup/msbuild:AssemblyName", namespaceManager);
string assemblyName = assemblyNameElement == null ? Name : assemblyNameElement.InnerText;
XmlElement outputTypeElement = (XmlElement)_doc.SelectSingleNode("/msbuild:Project/msbuild:PropertyGroup/msbuild:OutputType", namespaceManager);
string outputType = outputTypeElement == null ? "Library" : outputTypeElement.InnerText;
if (outputType == "Exe" || outputType == "WinExe")
{
assemblyName = assemblyName + ".exe";
}
else
{
assemblyName = assemblyName + ".dll";
}
string commonOutputPath = null;
var explicitOutputPaths = new Dictionary <string, string>();
foreach (XmlElement configNode in nodes)
{
string name = GetConfigNameFromCondition(configNode);
XmlElement outputPathElement = (XmlElement)configNode.SelectSingleNode("msbuild:OutputPath", namespaceManager);
string outputPath = null;
if (outputPathElement != null)
{
outputPath = outputPathElement.InnerText;
}
if (name == null)
{
if (outputPathElement != null)
{
commonOutputPath = outputPath;
}
continue;
}
if (outputPathElement != null)
{
explicitOutputPaths[name] = outputPath;
}
if (outputPath == null)
{
outputPath = explicitOutputPaths.ContainsKey(name) ? explicitOutputPaths[name] : commonOutputPath;
}
if (outputPath != null)
{
_configs[name] = new ProjectConfig(this, name, outputPath.Replace("$(Configuration)", name), assemblyName);
}
}
}
public static void Add(string directory, string path, ProjectConfig project)
{
if (!Directory.Exists(Path.Combine(directory, "platforms")))
{
Directory.CreateDirectory(Path.Combine(directory, "platforms"));
}
if (Directory.Exists(Path.Combine(directory, "platforms", "IOS")))
{
Console.WriteLine("IOS platform already exists");
return;
}
var iosPlatform = Path.Combine(directory, "platforms", "IOS");
Directory.CreateDirectory(iosPlatform);
var clientPath = Path.Combine(path, "Client.IOS");
File.Copy(Path.Combine(clientPath, "Program.cs"), Path.Combine(iosPlatform, "Program.cs"));
File.Copy(Path.Combine(clientPath, "GameClient.cs"), Path.Combine(iosPlatform, "GameClient.cs"));
File.Copy(Path.Combine(clientPath, "Info.plist"), Path.Combine(iosPlatform, "Info.plist"));
File.Copy(Path.Combine(clientPath, "GameThumbnail.png"), Path.Combine(iosPlatform, "GameThumbnail.png"));
File.Copy(Path.Combine(clientPath, "Entitlements.plist"), Path.Combine(iosPlatform, "Entitlements.plist"));
File.Copy(Path.Combine(clientPath, "Default.png"), Path.Combine(iosPlatform, "Default.png"));
File.Copy(Path.Combine(clientPath, "Client.IOSGame.csproj"), Path.Combine(iosPlatform, "Client.IOSGame.csproj"));
File.Copy(Path.Combine(clientPath, "Client.IOSGame.sln"), Path.Combine(iosPlatform, "Client.IOSGame.sln"));
Directory.CreateDirectory(Path.Combine(iosPlatform, "Properties/"));
Directory.CreateDirectory(Path.Combine(iosPlatform, "Assets/"));
Directory.CreateDirectory(Path.Combine(iosPlatform, "Content/"));
Directory.CreateDirectory(Path.Combine(iosPlatform, "Resources/"));
File.Copy(Path.Combine(clientPath, "Properties/AssemblyInfo.cs"), Path.Combine(iosPlatform, "Properties/AssemblyInfo.cs"));
File.Copy(Path.Combine(clientPath, "Content/Content.mgcb"), Path.Combine(iosPlatform, "Content/Content.mgcb"));
FileUtils.DirectoryCopy("none", Path.Combine(clientPath, "Resources"), Path.Combine(iosPlatform, "Resources"), true);
Directory.CreateDirectory(Path.Combine(iosPlatform, "Engine"));
Directory.CreateDirectory(Path.Combine(iosPlatform, "Engine.Xna"));
Directory.CreateDirectory(Path.Combine(iosPlatform, "Game"));
var engineFiles = FileUtils.DirectoryCopy(Path.Combine(iosPlatform), Path.Combine(path, "Engine"), Path.Combine(iosPlatform, "Engine"), true, "*.cs");
engineFiles.AddRange(FileUtils.DirectoryCopy(Path.Combine(iosPlatform), Path.Combine(path, "Engine.Xna"), Path.Combine(iosPlatform, "Engine.Xna"), true, "*.cs"));
File.WriteAllText(Path.Combine(iosPlatform, "GameClient.cs"), File.ReadAllText(Path.Combine(iosPlatform, "GameClient.cs")).Replace("{{{projectName}}}", "new " + project.ProjectName + ".Game()"));
engineFiles.Add("Program.cs");
engineFiles.Add("GameClient.cs");
engineFiles.Add(@"Properties\AssemblyInfo.cs");
Engine eng = new Engine();
Project proj = new Project(eng);
proj.Load(Path.Combine(iosPlatform, "Client.IOSGame.csproj"));
foreach (BuildItemGroup projItemGroup in proj.ItemGroups)
{
if (projItemGroup.ToArray().Any(a => a.Name == "Compile"))
{
foreach (var buildItem in projItemGroup.ToArray())
{
projItemGroup.RemoveItem(buildItem);
}
foreach (var engineFile in engineFiles)
{
projItemGroup.AddNewItem("Compile", engineFile);
}
var item = projItemGroup.AddNewItem("Compile", "..\\..\\src\\**\\*.cs");
item.SetMetadata("Link", "Game\\%(RecursiveDir)%(Filename)%(Extension)");
item.SetMetadata("CopyToOutputDirectory", "PreserveNewest");
break;
}
}
proj.Save(Path.Combine(iosPlatform, "Client.IOSGame.csproj"));
}
public void SetPrioritys()
{
ProjectConfig config = new ProjectConfig();
var prioritys = new List<TaskPriority> { TaskPriority.Highest };
config.SetPrioritys(prioritys);
var result_prioritys = config.GetPrioritys();
Assert.That(result_prioritys.Count, Is.EqualTo(1));
Assert.That(result_prioritys.Contains(TaskPriority.Highest));
}
public static void Run(string directory, ProjectConfig project, BuildResult build)
{
var iosPlatform = Path.Combine(directory, "platforms", "IOS");
System.Diagnostics.Process.Start(Path.Combine(iosPlatform, "Client.IOSGame.sln"));
}
public bool?Evaluate(ProjectConfig config, UserAttributes attributes, ILogger logger)
{
var result = Condition?.Evaluate(config, attributes, logger);
return(result == null ? null : !result);
}
public static BuildResult Build(string directory, ProjectConfig config)
{
if (!Directory.Exists(Path.Combine(directory, "platforms")))
{
throw new Exception("No Platforms");
}
if (!Directory.Exists(Path.Combine(directory, "platforms", "IOS")))
{
throw new Exception("IOS platform does not exist");
}
var platformFolder = Path.Combine(directory, "platforms", "IOS");
var imagesFolder = Path.Combine(directory, "assets", "images");
var fontsFolder = Path.Combine(directory, "assets", "fonts");
var songsFolder = Path.Combine(directory, "assets", "songs");
var soundsFolder = Path.Combine(directory, "assets", "sounds");
var platformAssetsFolder = Path.Combine(platformFolder, "Content", "images");
var platformFontsFolder = Path.Combine(platformFolder, "Content", "fonts");
var platformFontsAssetsFolder = Path.Combine(platformFolder, "Assets", "fonts");
var platformSongsFolder = Path.Combine(platformFolder, "Content", "songs");
var platformSoundsFolder = Path.Combine(platformFolder, "Content", "sounds");
var platformGameFolder = Path.Combine(platformFolder, "Game");
var platformContent = Path.Combine(platformFolder, "Content");
var iosPlatform = Path.Combine(directory, "platforms", "IOS");
if (Directory.Exists(platformAssetsFolder))
{
Directory.Delete(platformAssetsFolder, true);
}
if (Directory.Exists(platformFontsFolder))
{
Directory.Delete(platformFontsFolder, true);
}
if (Directory.Exists(platformFontsAssetsFolder))
{
Directory.Delete(platformFontsAssetsFolder, true);
}
if (Directory.Exists(platformSongsFolder))
{
Directory.Delete(platformSongsFolder, true);
}
if (Directory.Exists(platformSoundsFolder))
{
Directory.Delete(platformSoundsFolder, true);
}
if (Directory.Exists(platformGameFolder))
{
Directory.Delete(platformGameFolder, true);
}
//copy assets
var names = FileUtils.DirectoryCopy(platformContent, imagesFolder, platformAssetsFolder, true);
var fontFiles = FileUtils.DirectoryCopy(platformContent, fontsFolder, platformFontsFolder, true);
FileUtils.DirectoryCopy(platformContent, fontsFolder, platformFontsAssetsFolder, true);
var songFiles = FileUtils.DirectoryCopy(platformContent, songsFolder, platformSongsFolder, true);
var soundsFiles = FileUtils.DirectoryCopy(platformContent, soundsFolder, platformSoundsFolder, true);
var xmlFontFiles = fontFiles.Where(a => a.EndsWith(".xml"));
names.AddRange(fontFiles.Where(a => a.EndsWith(".png")));
var contentFile = new List <string>();
contentFile.Add("/platform:iOS");
contentFile.Add("/profile:Reach");
contentFile.Add("/compress:False");
contentFile.Add("/importer:TextureImporter");
contentFile.Add("/processor:TextureProcessor");
contentFile.Add("/processorParam:ColorKeyColor=255,0,255,255");
contentFile.Add("/processorParam:ColorKeyEnabled=True");
contentFile.Add("/processorParam:GenerateMipmaps=False");
contentFile.Add("/processorParam:PremultiplyAlpha=True");
contentFile.Add("/processorParam:ResizeToPowerOfTwo=False");
contentFile.Add("/processorParam:MakeSquare=False");
contentFile.Add("/processorParam:TextureFormat=Color");
foreach (var name in names)
{
contentFile.Add("/build:" + name);
}
contentFile.Add("/importer:Mp3Importer");
contentFile.Add("/processor:SongProcessor");
contentFile.Add("/processorParam:Quality=Best");
foreach (var name in songFiles)
{
contentFile.Add("/build:" + name);
}
contentFile.Add("/importer:WavImporter");
contentFile.Add("/processor:SoundEffectProcessor");
contentFile.Add("/processorParam:Quality=Best");
foreach (var name in soundsFiles)
{
contentFile.Add("/build:" + name);
}
File.WriteAllLines(Path.Combine(platformContent, "Content.mgcb"), contentFile);
Engine eng = new Engine();
Project proj = new Project(eng);
proj.Load(Path.Combine(iosPlatform, "Client.IOSGame.csproj"));
foreach (BuildItemGroup projItemGroup in proj.ItemGroups)
{
if (projItemGroup.ToArray().Any(a => a.Name == "BundleResource"))
{
foreach (var buildItem in projItemGroup.ToArray())
{
if (buildItem.Include.IndexOf("Assets\\") == 0 || buildItem.Include.IndexOf("Content\\") == 0)
{
projItemGroup.RemoveItem(buildItem);
}
}
foreach (var engineFile in xmlFontFiles)
{
projItemGroup.AddNewItem("Content", "Assets\\" + engineFile);
}
foreach (var name in names)
{
projItemGroup.AddNewItem("BundleResource", "Content\\" + name);
}
foreach (var name in soundsFiles)
{
projItemGroup.AddNewItem("Content", "Content\\" + name);
}
foreach (var name in songFiles)
{
projItemGroup.AddNewItem("Content", "Content\\" + name);
}
}
}
proj.Save(Path.Combine(iosPlatform, "Client.IOSGame.csproj"));
return(build(Path.Combine(iosPlatform, "Client.IOSGame.csproj"), config));
}
void PopulateModelFromConfig(ProjectConfig config)
{
_model.ClearPluginItems();
foreach (var name in config.PluginsFolder)
{
_model.AddPluginItem(name);
}
_model.ClearAssetItems();
foreach (var name in config.AssetsFolder)
{
_model.AddAssetItem(name);
}
_model.ClearSolutionProjects();
foreach (var name in config.SolutionProjects)
{
_model.AddVsProject(name);
}
_model.ClearSolutionFolders();
foreach (var pair in config.SolutionFolders)
{
_model.AddSolutionFolder(pair.Key, pair.Value);
}
}
/// <summary>
/// 执行器
/// </summary>
public override bool Execute(ProjectConfig project)
{
return(true);
}
public ActionResult AddProjectConfig(AddProjectConfigModel addProjectConfig)
{
if (null == addProjectConfig)
return View("Error");
// Validate ParentProjectId
var parentProjectId = addProjectConfig.ParentProjectId;
if (parentProjectId < 1)
return View("Error");
// Validate ParentProjectName
var parentProjectName = addProjectConfig.ParentProjectName;
if (string.IsNullOrWhiteSpace(parentProjectName))
return View("Error");
// Validate Name
var name = addProjectConfig.Name;
if (string.IsNullOrWhiteSpace(name))
return View("Error");
var desc = addProjectConfig.Description;
if (string.IsNullOrWhiteSpace(desc))
desc = null;
var buildNumberPostion = (int)addProjectConfig.BuildNumberPosition;
if (buildNumberPostion < 3 || buildNumberPostion > 4)
return View("Error");
// Force the GeneratedVersion part that corresponds to the build number position to a value of zero.
switch (buildNumberPostion)
{
case 3:
addProjectConfig.GeneratedVersionPart3 = 0;
break;
case 4:
addProjectConfig.GeneratedVersionPart4 = 0;
break;
}
using (var db = new BuildVersioningDataContext())
{
if (db.ProjectConfigs
.Include(c => c.Project)
.Any(c =>
c.Project.Id == parentProjectId &&
string.Compare(c.Name, name, StringComparison.OrdinalIgnoreCase) == 0
))
return View("Error"); // <-- A ProjectConfig with the same parent Project and the same name already exists.
var projectConfig =
new ProjectConfig
{
Description = desc,
GeneratedBuildNumberPosition = buildNumberPostion,
GeneratedVersionPart1 = addProjectConfig.GeneratedVersionPart1,
GeneratedVersionPart2 = addProjectConfig.GeneratedVersionPart2,
GeneratedVersionPart3 = addProjectConfig.GeneratedVersionPart3,
GeneratedVersionPart4 = addProjectConfig.GeneratedVersionPart4,
Name = name,
ProductVersionPart1 = addProjectConfig.ProductVersionPart1,
ProductVersionPart2 = addProjectConfig.ProductVersionPart2,
ProductVersionPart3 = addProjectConfig.ProductVersionPart3,
ProductVersionPart4 = addProjectConfig.ProductVersionPart4,
ProjectId = parentProjectId,
ReleaseType = addProjectConfig.ReleaseType
};
db.ProjectConfigs.Add(projectConfig);
db.SaveChanges();
}
return RedirectToRoute("ViewProject", new { name = parentProjectName });
}
private string GetRemoteTargetDataPath(ProjectConfig target)
{
return(Path.Combine(ModuleRoot.OriginalString, s_ModulePath, target.ProjectName, target.ProjectVersion));
}
public void SaveAndLoadConfigsWithAssemblies()
{
ProjectConfig config1 = new ProjectConfig( "Debug" );
config1.Assemblies.Add( Path.GetFullPath( @"bin\debug\assembly1.dll" ) );
config1.Assemblies.Add( Path.GetFullPath( @"bin\debug\assembly2.dll" ) );
ProjectConfig config2 = new ProjectConfig( "Release" );
config2.Assemblies.Add( Path.GetFullPath( @"bin\release\assembly1.dll" ) );
config2.Assemblies.Add( Path.GetFullPath( @"bin\release\assembly2.dll" ) );
project.Configs.Add( config1 );
project.Configs.Add( config2 );
project.Save( xmlfile );
Assert.IsTrue( File.Exists( xmlfile ) );
NUnitProject project2 = projectService.LoadProject( xmlfile );
Assert.AreEqual( 2, project2.Configs.Count );
config1 = project2.Configs["Debug"];
Assert.AreEqual( 2, config1.Assemblies.Count );
Assert.AreEqual( Path.GetFullPath( @"bin\debug\assembly1.dll" ), config1.Assemblies[0] );
Assert.AreEqual( Path.GetFullPath( @"bin\debug\assembly2.dll" ), config1.Assemblies[1] );
config2 = project2.Configs["Release"];
Assert.AreEqual( 2, config2.Assemblies.Count );
Assert.AreEqual( Path.GetFullPath( @"bin\release\assembly1.dll" ), config2.Assemblies[0] );
Assert.AreEqual( Path.GetFullPath( @"bin\release\assembly2.dll" ), config2.Assemblies[1] );
}
public static string SerializeProjectConfig(ProjectConfig info)
{
return YamlSerializer.Serialize<ProjectConfigInternal>(ConvertToInternal(info));
}
/// <summary>
/// Initialize ProjectConfig and internal projectMgr objects.
/// </summary>
/// <remarks>Service function. Before calling this function projectNode must be
/// initialized by valid project data.</remarks>
protected void PrepareProjectConfig()
{
object[] ppUnk = new object[2];
ProjectConfig pjc = new ProjectConfig(projectNode, "manualSetConfigArgument", "manualSetPlatformArgument");
ppUnk[0] = pjc;
generalPropertyPage.SetObjects(1, ppUnk);
}
private static List <ProjectConfig> LoadProjectConfigs()
{
Logger.Info("Loading project configs");
var fileMappingsquery = from r in ais_dev.VDC_FILE_MAPPINGS
join n in ais_dev.VDC_PROJECTS on r.MAP_PROJECT_NUMBER equals n.PROJECT_NUMBER
select new {
r.MAP_PROJECT_NUMBER,
n.PROJECT_NAME,
r.MAP_FTP_SOURCE,
r.MAP_COMPANY_ID,
r.MAP_PROJECT_ID,
r.MAP_TYPE,
r.MAPPING_ID
};
var fileMappings = fileMappingsquery.ToList();
var projectNumbers = fileMappings.Select(x => (int)x.MAP_PROJECT_NUMBER).Distinct();
var projectConfigs = new List <ProjectConfig>();
foreach (var projectNumber in projectNumbers)
{
var projectConfig = new ProjectConfig {
projectNumber = projectNumber,
projectName = fileMappings.First(x => x.MAP_PROJECT_NUMBER == projectNumber).PROJECT_NAME,
downloadDirectory = Path.Combine(@"\\cannfilesvr01.cannistraro.local\sys\data\everyone\VDC Group\_BIM Support\Turing\Downloads",
$"{projectNumber} - {fileMappings.First(x => x.MAP_PROJECT_NUMBER == projectNumber).PROJECT_NAME}") // TODO remove cannistraro.local?
};
var configSourceNames = fileMappings.Where(x => x.MAP_PROJECT_NUMBER == projectNumber).Select(x => x.MAP_FTP_SOURCE).Distinct();
foreach (var sourceName in configSourceNames)
{
var sourceMappings = fileMappings.Where(x => x.MAP_PROJECT_NUMBER == projectNumber && x.MAP_FTP_SOURCE == sourceName);
var source = new Source {
ftpType = (FtpType)Enum.Parse(typeof(FtpType), sourceName),
// assume at most one companyId and projectId per source
// (max. one glue source per project, max. one procore source per project, etc.)
companyId = sourceMappings.First().MAP_COMPANY_ID,
projectId = sourceMappings.First().MAP_PROJECT_ID,
mappings = sourceMappings.Select(x =>
new Mapping {
id = x.MAPPING_ID,
mappingType = (MappingType)Enum.Parse(typeof(MappingType), x.MAP_TYPE)
}
).ToList(),
};
projectConfig.sources.Add(source);
}
projectConfigs.Add(projectConfig);
}
return(projectConfigs);
}
