protected override void OnExecute()
{
if (this.Culture != string.Empty)
{
System.Globalization.CultureInfo.DefaultThreadCurrentCulture = new System.Globalization.CultureInfo(this.Culture);
System.Globalization.CultureInfo.DefaultThreadCurrentUICulture = new System.Globalization.CultureInfo(this.Culture);
}
this.Out.WriteLine("receiving info");
var metaData = this.service.GetMetaData(this.Address, DataBaseSettings.DataBaseName, DataBaseSettings.Tags, FilterSettings.FilterExpression, CodeSettings.Devmode, this.Revision);
metaData = ReplaceOptionProcessor.Process(metaData);
var generationSettings = new CodeGenerationSettings()
{
ClassName = CodeSettings.ClassName,
Namespace = CodeSettings.Namespace,
BaseNamespace = CodeSettings.BaseNamespace,
Prefix = CodeSettings.Prefix,
Postfix = CodeSettings.Postfix,
BasePath = CodeSettings.BasePath,
Options = CodeSettings.Options,
Tags = (TagInfo)DataBaseSettings.Tags,
Revision = this.Revision,
};
foreach (var item in CommandStringUtility.ArgumentsToDictionary(this.Arguments))
{
generationSettings.Arguments.Add(item);
}
if (CodeSettings.IsBuildMode == true)
{
var compiler = this.compilers.FirstOrDefault(item => item.Name == CodeSettings.LanguageType);
if (compiler == null)
{
throw new InvalidOperationException($"'{CodeSettings.LanguageType}'은(는) 존재하지 않는 언어입니다.");
}
this.Out.WriteLine("compiling code.");
compiler.Compile(this.OutputPath, metaData.Item1, generationSettings, CodeSettings.BuildTarget);
this.Out.WriteLine("code compiled.");
}
else
{
this.Out.WriteLine("code generating.");
var generator = this.generators.FirstOrDefault(item => item.Name == CodeSettings.LanguageType);
if (generator == null)
{
throw new InvalidOperationException($"'{CodeSettings.LanguageType}'은(는) 존재하지 않는 언어입니다.");
}
generator.Generate(this.OutputPath, metaData.Item1, generationSettings);
this.Out.WriteLine("code generated.");
}
this.Out.WriteLine("data serializing.");
var serializer = this.serializers.FirstOrDefault(item => item.Name == this.DataType);
serializer.Serialize(Path.Combine(this.OutputPath, this.DataFilename), metaData.Item2);
this.Out.WriteLine("data serialized.");
}
private async Task CompileCodeAsync()
{
var compiler = this.compilers.FirstOrDefault(item => item.Name == CodeSettings.LanguageType);
if (compiler == null)
{
throw new InvalidOperationException($"'{CodeSettings.LanguageType}'은(는) 존재하지 언어입니다.");
}
this.Out.WriteLine("receiving info");
var metaData = await this.service.GetMetaDataAsync(this.Address, DataBaseSettings.DataBaseName, DataBaseSettings.Tags, FilterSettings.FilterExpression, null);
var generationSettings = new CodeGenerationSettings()
{
ClassName = CodeSettings.ClassName,
Namespace = CodeSettings.Namespace,
BaseNamespace = CodeSettings.BaseNamespace,
Prefix = CodeSettings.Prefix,
Postfix = CodeSettings.Postfix,
BasePath = CodeSettings.BasePath,
Options = CodeSettings.Options,
Tags = (TagInfo)DataBaseSettings.Tags,
Revision = this.Revision,
};
this.Out.WriteLine("code compiling.");
compiler.Compile(this.OutputPath, metaData.Item1, generationSettings, CodeSettings.BuildTarget);
this.Out.WriteLine("code compiled.");
}
private void GenerateCode()
{
var generator = this.generators.FirstOrDefault(item => item.Name == CodeSettings.LanguageType);
if (generator == null)
{
throw new InvalidOperationException($"'{CodeSettings.LanguageType}'은(는) 존재하지 언어입니다.");
}
this.Out.WriteLine("receiving info");
var metaData = this.service.GetMetaData(this.Address, DataBaseSettings.DataBaseName, DataBaseSettings.Tags, FilterSettings.FilterExpression, CodeSettings.Devmode, this.Revision);
var generationSettings = new CodeGenerationSettings()
{
ClassName = CodeSettings.ClassName,
Namespace = CodeSettings.Namespace,
BaseNamespace = CodeSettings.BaseNamespace,
Prefix = CodeSettings.Prefix,
Postfix = CodeSettings.Postfix,
BasePath = CodeSettings.BasePath,
Options = CodeSettings.Options,
Tags = (TagInfo)DataBaseSettings.Tags,
Revision = this.Revision,
};
this.Out.WriteLine("generating code.");
generator.Generate(this.OutputPath, metaData.Item1, generationSettings);
this.Out.WriteLine("code generated.");
}
public void Compile(string outputPath, GenerationSet metaData, CodeGenerationSettings settings, string target)
{
var generationInfo = new CodeGenerationInfo(outputPath, metaData, settings);
if (settings.Options.HasFlag(CodeGenerationOptions.OmitCode) == false && settings.Options.HasFlag(CodeGenerationOptions.OmitBaseCode) == false)
{
var filename = this.CompileAll(outputPath, generationInfo, target);
this.PrintResult(filename);
}
else if (settings.Options.HasFlag(CodeGenerationOptions.OmitCode) == true)
{
var filename = this.CompileBase(outputPath, generationInfo, target);
this.PrintResult(filename);
}
else if (settings.Options.HasFlag(CodeGenerationOptions.OmitBaseCode) == true)
{
var tempPath = PathUtility.GetTempPath(true);
try
{
var readerPath = this.CompileBase(tempPath, generationInfo, target);
var filename = this.Compile(outputPath, readerPath, generationInfo, target);
this.PrintResult(filename);
}
finally
{
DirectoryUtility.Delete(tempPath);
}
}
}
public void Generate(string outputPath, GenerationSet metaData, CodeGenerationSettings settings)
{
var path = PathUtility.GetFullPath(outputPath);
var generationInfo = new CodeGenerationInfo(path, metaData, settings);
if (settings.Options.HasFlag(CodeGenerationOptions.OmitCode) == false)
{
var codes = this.GenerateCodes(generationInfo);
foreach (var item in codes)
{
var codePath = FileUtility.WriteAllText(item.Value, Encoding.UTF8, path, item.Key);
this.PrintResult(codePath);
}
}
if (settings.Options.HasFlag(CodeGenerationOptions.OmitBaseCode) == false)
{
var codes = this.GenerateBaseCodes(generationInfo);
foreach (var item in codes)
{
var codePath = FileUtility.WriteAllText(item.Value, Encoding.UTF8, path, item.Key);
this.PrintResult(codePath);
}
}
}
public void Compile(string outputPath, GenerationSet metaData, CodeGenerationSettings settings, string target)
{
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
var generationInfo = new CodeGenerationInfo(outputPath, metaData, settings);
var codes1 = this.GenerateCodes(generationInfo);
var codes2 = this.GenerateBaseCodes(generationInfo);
var codes3 = codes1.Concat(codes2).ToDictionary(item => item.Key, item => item.Value);
var codes = TypeScriptCompiler.Compile(codes3, target == string.Empty ? "ES5" : target);
if (Directory.Exists(outputPath) == false)
{
Directory.CreateDirectory(outputPath);
}
foreach (var item in codes)
{
string codePath = Path.Combine(outputPath, item.Key);
using (StreamWriter sw = new StreamWriter(codePath, false, Encoding.UTF8))
{
sw.WriteLine(item.Value);
this.PrintResult(codePath);
}
}
}
public CodeGenerationInfo(string outputPath, GenerationSet metaData, CodeGenerationSettings settings)
{
this.metaData = metaData;
this.settings = settings;
if (this.settings.BasePath != string.Empty)
{
var relativePath = UriUtility.MakeRelativeOfDirectory(new DirectoryInfo(outputPath).FullName, DirectoryUtility.GetAbsolutePath(outputPath, settings.BasePath));
this.RelativePath = relativePath + Path.DirectorySeparatorChar;
}
}
public void Generate(string outputPath, GenerationSet metaData, CodeGenerationSettings settings)
{
var generationInfo = new CodeGenerationInfo(metaData, settings)
{
RelativePath = string.Empty,
};
if (settings.BasePath != string.Empty)
{
var relativePath = UriUtility.MakeRelativeOfDirectory(new DirectoryInfo(outputPath).FullName, DirectoryUtility.GetAbsolutePath(outputPath, settings.BasePath));
generationInfo.RelativePath = relativePath + "/";
}
{
var codes = this.Generate(generationInfo);
var dirInfo = new DirectoryInfo(outputPath);
var rootPath = generationInfo.Namespace.Replace('.', Path.DirectorySeparatorChar);
foreach (var item in codes)
{
var ext = Path.GetExtension(item.Key);
var filename = FileUtility.RemoveExtension(item.Key).Replace('.', Path.DirectorySeparatorChar) + ext;
filename = Path.Combine(dirInfo.FullName, filename);
FileUtility.Prepare(filename);
using (StreamWriter sw = new StreamWriter(filename, false, Encoding.UTF8))
{
sw.WriteLine(item.Value);
this.PrintResult(filename);
}
}
}
if (settings.Options.HasFlag(CodeGenerationOptions.OmitBaseCode) == false)
{
var codes = this.GenerateBases(generationInfo);
var codesPath = DirectoryUtility.GetAbsolutePath(outputPath, settings.BasePath);
foreach (var item in codes)
{
var codePath = FileUtility.Prepare(codesPath, item.Key);
using (var writer = new StreamWriter(codePath, false, Encoding.UTF8))
{
writer.WriteLine(item.Value);
this.PrintResult(codePath);
}
}
}
}
static CreateViewTemplateListener()
{
if (EditorPrefs.GetBool("CreateTestScreenWizard"))
{
EditorPrefs.SetBool("CreateTestScreenWizard", false);
string name = EditorPrefs.GetString("Name");
string testType = EditorPrefs.GetString("Type");
EditorPrefs.DeleteKey("Name");
EditorPrefs.DeleteKey("Type");
EditorPrefs.DeleteKey("ScriptRootPath");
_settings = AssetDatabase.LoadAssetAtPath <CodeGenerationSettings>(CodeGenPaths.SETTINGS_PATH);
//Instantiate root GameObject.
if (!TryInstantiateRootInstance(name, testType, out GameObject instanceRootGameObject))
{
Debug.LogError("Could not instantiate root instance!");
return;
}
//Creating the skeleton gameObject of panel.
GameObject screenGameObject = CreateScreenViewGameObject(name, testType);
//Turning skeleton gameObject to a usable prefab.
CreatePrefabOnPathFromInstance(_settings.ProjectResourcesPath + "/" + testType, name, screenGameObject, out GameObject usableScreenPrefab);
//Re-assigning to prefab instance.
screenGameObject = PrefabUtility.InstantiatePrefab(usableScreenPrefab) as GameObject;
//Using Layer0 we will delete any screens that exist.
GameObject screenContainer = GameObject.Find("Layer0");
if (screenContainer.transform.childCount > 0)
{
Object.DestroyImmediate(screenContainer.transform.GetChild(0).gameObject);
}
if (screenGameObject != null)
{
screenGameObject.transform.SetParent(screenContainer.transform);
screenGameObject.GetComponent <RectTransform>().localScale = Vector3.one;
}
EditorSceneManager.MarkAllScenesDirty();
}
}
public void Generate(string outputPath, GenerationSet metaData, CodeGenerationSettings settings)
{
var generationInfo = new CodeGenerationInfo(metaData, settings);
var codes = this.Generate(generationInfo);
foreach (var item in codes)
{
string codePath = FileUtility.Prepare(outputPath, item.Key);
using (StreamWriter sw = new StreamWriter(codePath, false, Encoding.UTF8))
{
sw.WriteLine(item.Value);
this.PrintResult(codePath);
}
}
}
private void OnWizardCreate()
{
if (string.IsNullOrEmpty(Name))
{
return;
}
_settings = AssetDatabase.LoadAssetAtPath <CodeGenerationSettings>(CodeGenPaths.SETTINGS_PATH);
_operationConfig = _settings.PoolKeyGenerationConfig;
Dictionary <Type, object> startArgs = new Dictionary <Type, object>()
{
{
typeof(PoolKeyCodeOperation),
new PoolKeyCodeOperation.StartArgs()
{
Name = this.Name
}
}
};
foreach (CodeGenerationOperation operation in _operationConfig.Operations)
{
operation.Begin(startArgs);
}
//Create necessary operate args.
Dictionary <Type, object> operateArgs = new Dictionary <Type, object>()
{
};
foreach (CodeGenerationOperation operation in _operationConfig.Operations)
{
operation.Operate(operateArgs);
}
EditorPrefs.SetString("Name", Name);
AssetDatabase.Refresh();
}
private void OnWizardCreate()
{
if (string.IsNullOrEmpty(Name))
{
return;
}
_settings = AssetDatabase.LoadAssetAtPath <CodeGenerationSettings>(CodeGenPaths.SETTINGS_PATH);
_operationConfig = _settings.ScreenCodeGenerationConfig;
//Create necessary start args.
Dictionary <Type, object> startArgs = new Dictionary <Type, object>()
{
{
typeof(ScreenViewMediatorGenerationOperation),
new ScreenViewMediatorGenerationOperation.StartArgs()
{
Name = this.Name,
Type = this.Type,
ViewEventList = this.ViewEventList
}
},
{
typeof(RootContextGenerationOperation),
new RootContextGenerationOperation.StartArgs()
{
Name = this.Name,
Type = this.Type
}
},
{
typeof(GameScreensCodeOperation),
new GameScreensCodeOperation.StartArgs()
{
Name = this.Name
}
},
{
typeof(CreateSceneGenerationOperation),
new CreateSceneGenerationOperation.StartArgs()
{
Name = this.Name
}
}
};
foreach (CodeGenerationOperation operation in _operationConfig.Operations)
{
operation.Begin(startArgs);
}
//Create necessary operate args.
Dictionary <Type, object> operateArgs = new Dictionary <Type, object>()
{
};
foreach (CodeGenerationOperation operation in _operationConfig.Operations)
{
operation.Operate(operateArgs);
}
//This is for InitializeOnLoad code above.
EditorPrefs.SetBool("CreateTestScreenWizard", true);
EditorPrefs.SetString("Name", Name);
EditorPrefs.SetString("Type", Type);
AssetDatabase.Refresh();
}
public CodeService(IOptions <CodeGenerationSettings> options)
{
_options = options.Value;
}
public CodeGenerationInfo(GenerationSet metaData, CodeGenerationSettings settings)
{
this.metaData = metaData;
this.settings = settings;
this.EnumFomrat = (v) => $"0x{(int)v:x8}";
}
/// <summary>
/// Constructs a instance of Uglify JS minifier
/// </summary>
/// <param name="createJsEngineInstance">Delegate that creates an instance of JS engine</param>
/// <param name="uglifyConfig">Configuration settings of Uglify Minifier</param>
public UglifyJsMinifier(Func <IJsEngine> createJsEngineInstance, UglifySettings uglifyConfig)
{
JsMinifierSettings jsMinifierConfig = uglifyConfig.Js;
ParsingSettings parsingConfig = jsMinifierConfig.Parsing;
CompressionSettings compressionConfig = jsMinifierConfig.Compression;
ManglingSettings manglingConfig = jsMinifierConfig.Mangling;
CodeGenerationSettings codeGenerationConfig = jsMinifierConfig.CodeGeneration;
ParsingOptions = new ParsingOptions
{
BareReturns = parsingConfig.BareReturns,
Strict = parsingConfig.Strict
};
CompressionOptions = new CompressionOptions
{
Angular = compressionConfig.Angular,
Booleans = compressionConfig.Booleans,
Cascade = compressionConfig.Cascade,
CollapseVars = compressionConfig.CollapseVars,
Comparisons = compressionConfig.Comparisons,
Compress = compressionConfig.Compress,
Conditionals = compressionConfig.Conditionals,
DeadCode = compressionConfig.DeadCode,
DropConsole = compressionConfig.DropConsole,
DropDebugger = compressionConfig.DropDebugger,
Evaluate = compressionConfig.Evaluate,
GlobalDefinitions = compressionConfig.GlobalDefinitions,
HoistFunctions = compressionConfig.HoistFunctions,
HoistVars = compressionConfig.HoistVars,
IfReturn = compressionConfig.IfReturn,
JoinVars = compressionConfig.JoinVars,
KeepFunctionArgs = compressionConfig.KeepFunctionArgs,
KeepInfinity = compressionConfig.KeepInfinity,
Loops = compressionConfig.Loops,
NegateIife = compressionConfig.NegateIife,
Passes = compressionConfig.Passes,
PropertiesDotNotation = compressionConfig.PropertiesDotNotation,
PureGetters = compressionConfig.PureGetters,
PureFunctions = compressionConfig.PureFunctions,
ReduceVars = compressionConfig.ReduceVars,
Sequences = compressionConfig.Sequences,
TopLevel = compressionConfig.TopLevel,
TopRetain = compressionConfig.TopRetain,
Unsafe = compressionConfig.Unsafe,
UnsafeMath = compressionConfig.UnsafeMath,
UnsafeProto = compressionConfig.UnsafeProto,
UnsafeRegExp = compressionConfig.UnsafeRegExp,
Unused = compressionConfig.Unused
};
ManglingOptions = new ManglingOptions
{
Eval = manglingConfig.Eval,
Except = manglingConfig.Except,
Mangle = manglingConfig.Mangle,
TopLevel = manglingConfig.TopLevel,
};
CodeGenerationOptions = new CodeGenerationOptions
{
AsciiOnly = codeGenerationConfig.AsciiOnly,
Beautify = codeGenerationConfig.Beautify,
Bracketize = codeGenerationConfig.Bracketize,
Comments = codeGenerationConfig.Comments,
IndentLevel = codeGenerationConfig.IndentLevel,
IndentStart = codeGenerationConfig.IndentStart,
InlineScript = codeGenerationConfig.InlineScript,
KeepQuotedProperties = codeGenerationConfig.KeepQuotedProperties,
MaxLineLength = codeGenerationConfig.MaxLineLength,
PreserveLine = codeGenerationConfig.PreserveLine,
QuoteKeys = codeGenerationConfig.QuoteKeys,
QuoteStyle = codeGenerationConfig.QuoteStyle,
Semicolons = codeGenerationConfig.Semicolons,
SpaceColon = codeGenerationConfig.SpaceColon,
UnescapeRegexps = codeGenerationConfig.UnescapeRegexps,
Width = codeGenerationConfig.Width,
WrapIife = codeGenerationConfig.WrapIife
};
KeepFunctionNames = jsMinifierConfig.KeepFunctionNames;
ScrewIe8 = jsMinifierConfig.ScrewIe8;
Severity = jsMinifierConfig.Severity;
if (createJsEngineInstance == null)
{
string jsEngineName = uglifyConfig.JsEngine.Name;
if (string.IsNullOrWhiteSpace(jsEngineName))
{
throw new ConfigurationErrorsException(
string.Format(CoreStrings.Configuration_JsEngineNotSpecified,
"uglify",
@"
* JavaScriptEngineSwitcher.Msie
* JavaScriptEngineSwitcher.V8
* JavaScriptEngineSwitcher.ChakraCore",
"MsieJsEngine")
);
}
createJsEngineInstance = () => JsEngineSwitcher.Instance.CreateEngine(jsEngineName);
}
_createJsEngineInstance = createJsEngineInstance;
}
