/// <summary>
/// コンストラクタ。
/// </summary>
/// <param name="message">メッセージプロバイダのインスタンス。</param>
/// <param name="project">プロジェクト情報のインスタンス。</param>
/// <param name="definition">スクリプト定義情報のインスタンス。</param>
public ScriptDefinitionValidator(
MessageProvider message,
WarlockProject project,
ScriptDefinition definition)
: base(message)
{
Project = project;
Definition = definition;
}
private void AddScript(ScriptDefinition script)
{
// Ignore scripts with the same name.
if (_scriptDefs.ContainsKey(script.Name))
{
Console.WriteLine($"Ignoring script with duplicate name: {script.Name}");
return;
}
_scriptDefs.Add(script.Name, script);
}
/// <summary>
/// 指定したスクリプト定義を使用したスクリプトエディタを開いているかチェックし、開いているなら該当するスクリプトエディタのインスタンスを返す。
/// </summary>
/// <param name="definition">スクリプト定義のインスタンス。</param>
/// <returns>指定したスクリプト定義を使用したスクリプトエディタを開いている場合はスクリプトエディタのインスタンスを返す。</returns>
private List<ScriptEditorTab> FindEdittingScriptEditors(ScriptDefinition definition)
{
var ret = new List<ScriptEditorTab>();
foreach (var editor in MainForm.GetScriptEditors())
{
if (editor.Definition.Equals(definition))
{
ret.Add(editor);
}
}
return ret;
}
/// <summary>
///
/// </summary>
/// <param name="sd"></param>
/// <param name="errors"></param>
/// <returns></returns>
protected bool TryCompileScript(ScriptDefinition sd, out string[] errors)
{
List <string> aggregatingErrors = new List <string>();
if (IsCompiled)
{
errors = aggregatingErrors.ToArray();
return(true);
}
if (sd != null)
{
string[] onEntryErrors;
_script = new CsScriptRuntime(sd);
_script.TryCompile(out onEntryErrors);
aggregatingErrors.AddRange(onEntryErrors);
}
errors = aggregatingErrors.ToArray();
IsCompiled = true;
return(errors.Length == 0);
}
public void AddScript(string name, string description,
ulong guild, string author,
string @event, BlockExpression tree)
{
// We're adding a script that was just created; create its initial definition.
var definition = new ScriptDefinition
{
Name = name,
Description = description,
Guild = guild,
EventTrigger = @event,
Author = author,
CreationDate = DateTime.Now,
Enabled = false,
Tree = tree,
};
// Add and save the script.
AddScript(definition);
SaveScript(definition.Name);
}
/// <summary>
/// コンストラクタ。
/// </summary>
/// <param name="node">スクリプトノードのインスタンス。</param>
public ScriptPropartyBase(ScriptTreeNode node)
: base(node)
{
Definition = (ScriptDefinition)node.Tag;
Name = Definition.DisplayName;
Func<TreeNode, ProjectTreeNode> recursive = null;
recursive = (parent) =>
{
if (parent == null) return null;
if (parent is ProjectTreeNode) return (ProjectTreeNode)parent;
return recursive(parent.Parent);
};
var projectNode = recursive(node);
if (projectNode != null)
{
Project = (WarlockProject)projectNode.Tag;
}
}
/// <summary>
/// スクリプトのインポートを行う。
/// </summary>
/// <param name="parameter">パラメータ。</param>
private void ImportScriptDefinition(KeyValueMap parameters)
{
ScriptDefinition definition = parameters["Definition"];
using (var dialog = new OpenFileDialog())
{
dialog.Filter = ApplicationConstants.ScriptFileFilterString;
if (dialog.ShowDialog(MainForm) != DialogResult.OK) return;
ScriptDefinition newDefinition;
string fileName = Path.GetFileName(dialog.FileName);
string newPath = Project.GetScriptFullPath(fileName);
int i = 2;
while (File.Exists(newPath))
{
string newFileName = String.Format(
"{0}_{1}.rb",
Path.GetFileNameWithoutExtension(fileName),
i++
);
newPath = Project.GetScriptFullPath(newFileName);
}
try
{
File.Copy(dialog.FileName, newPath);
newDefinition = new ScriptDefinition()
{
FileName = newPath,
DisplayName = Path.GetFileNameWithoutExtension(dialog.FileName),
Guid = Project.NewScriptGuid()
};
if (definition == null)
{
Project.ScriptDefinitions.Add(newDefinition);
RefreshScriptNode(newDefinition);
}
else
{
definition.Children.Add(newDefinition);
RefreshScriptNode(definition);
}
}
catch (Exception ex)
{
ProvideMessage("Default.Exception.Error", "スクリプトのコピー", ex.Message);
return;
}
RefreshSelectedNodeProperty();
if (!SaveProject()) return;
RefreshObjectDefinition();
}
}
/// <summary>
/// ノードを生成する。
/// </summary>
/// <param name="definition">スクリプト定義のインスタンス。</param>
/// <returns>生成したツリーノード。</returns>
public static ScriptTreeNode Create(ScriptDefinition definition)
{
var ret = new ScriptTreeNode();
ret.Refresh(definition);
return ret;
}
/// <summary>
/// スクリプト定義を作成する。
/// </summary>
/// <param name="parameters">パラメータ。</param>
private void CreateScriptDefinition(KeyValueMap parameters)
{
ScriptDefinition definition = parameters["Definition"];
using (var dialog = new SaveFileDialog())
{
dialog.InitialDirectory = Project.ScriptFolderFullPath;
dialog.Filter = ApplicationConstants.ScriptFileFilterString;
dialog.OverwritePrompt = false;
if (dialog.ShowDialog(MainForm) != DialogResult.OK) return;
var validator = new ScriptDefinitionValidator(Message, Project, definition);
ProvidedMessage result;
string newPath = null;
result = validator.ValidateFileFullPath(dialog.FileName, ref newPath);
if (result != null)
{
InvokeMessage(result);
return;
}
result = validator.ValidateFileName(newPath);
if (result != null)
{
InvokeMessage(result);
return;
}
var newDefinition = new ScriptDefinition()
{
FileName = newPath,
DisplayName = ApplicationConstants.DefaultScriptName,
Guid = Project.NewScriptGuid()
};
if (definition == null)
{
Project.ScriptDefinitions.Add(newDefinition);
RefreshScriptNode(newDefinition);
}
else
{
definition.Children.Add(newDefinition);
RefreshScriptNode(definition);
}
if (!SaveProject()) return;
if (!File.Exists(Project.GetScriptFullPath(newDefinition.FileName)))
{
try
{
using (var fs = File.Create(Project.GetScriptFullPath(newDefinition.FileName))) { }
}
catch (Exception ex)
{
ProvideMessage("Default.Exception.Error", "スクリプトファイルの作成", ex.Message);
return;
}
}
RefreshObjectDefinition();
RegisterScriptEditor(newDefinition);
}
}
/// <summary>
/// スクリプトフォルダを作成する。
/// </summary>
/// <param name="parameters">パラメータ。</param>
private void CreateScriptFolder(KeyValueMap parameters)
{
ScriptDefinition definition = parameters["Definition"];
var newDefinition = new ScriptDefinition()
{
DisplayName = ApplicationConstants.DefaultScriptFolderName,
Guid = Project.NewScriptGuid()
};
if (definition == null)
{
Project.ScriptDefinitions.Add(newDefinition);
RefreshScriptNode(newDefinition);
}
else
{
definition.Children.Add(newDefinition);
RefreshScriptNode(definition);
}
if (!SaveProject()) return;
}
/// <summary>
/// スクリプトのインポートを行う。
/// </summary>
/// <param name="console">コンソールのインスタンス。</param>
public void ImportScript(WarlockConsole console = null)
{
// スクリプトのロード
if (console != null) console.WriteLine("========== インポート開始 ==========");
if (console != null) console.WriteLine("スクリプトをロード中 - {0}", ScriptFilePath);
var scriptDatas = WarlockDatabase.LoadScript(ScriptFilePath);
// 出力フォルダがなければ作成
if (!Directory.Exists(ScriptFolderFullPath))
{
Directory.CreateDirectory(ScriptFolderFullPath);
}
// 現在のスクリプト定義をクリア
var oldDefinitions = ClearScriptDefinitions();
int nonameIndex = 0;
var fileNameCheck = new Regex("^[A-Za-z0-9_]+$");
if (console != null) console.WriteLine("========== スクリプトを出力します ==========");
var scriptDefinitionMap = new Dictionary<int, ScriptDefinition>();
int fileCount = 0;
foreach (ScriptData scriptData in scriptDatas)
{
var definition = new ScriptDefinition()
{
Guid = scriptData.Guid,
DisplayName = scriptData.DisplayName
};
// 展開前の定義情報にある同一GUIDのデータを取得
ScriptDefinition oldDefinition = null;
if (oldDefinitions.ContainsKey(definition.Guid))
{
oldDefinition = oldDefinitions[definition.Guid];
}
string sourceCode = scriptData.SourceCode;
if (!String.IsNullOrEmpty(sourceCode))
{
// ソースコードが存在するならファイルを展開
if (oldDefinition != null && !oldDefinition.IsFolder)
{
// 旧定義が存在するなら旧定義を引き継ぐ
definition.FileName = oldDefinition.FileName;
definition.ExecuteTarget = oldDefinition.ExecuteTarget;
}
else
{
definition.FileName = String.Format("{0}.rb", definition.DisplayName);
try
{
// すでにファイルがある場合は別名を付ける
if (File.Exists(GetScriptFullPath(definition.FileName)))
{
int i = 1;
do
{
definition.FileName = String.Format("{0}_{1}.rb", definition.DisplayName, ++i);
} while (File.Exists(GetScriptFullPath(definition.FileName)));
}
}
catch
{
// 表現不可ならファイル名クリア
definition.FileName = "";
}
if (String.IsNullOrEmpty(definition.DisplayName) || !fileNameCheck.IsMatch(definition.DisplayName) || String.IsNullOrEmpty(definition.FileName))
{
do
{
definition.FileName = String.Format("UnnamedScript_{0}.rb", ++nonameIndex);
} while (File.Exists(GetScriptFullPath(definition.FileName)));
}
}
string outputPath = GetScriptFullPath(definition.FileName);
if (console != null) console.WriteLine("{0} -> {1}", definition.DisplayName, outputPath);
using (var sw = new StreamWriter(outputPath, append: false, encoding: new UTF8Encoding()))
{
sw.Write(sourceCode);
}
fileCount++;
}
scriptDefinitionMap.Add(definition.Guid, definition);
}
// 展開前データのツリー構造を復元
foreach (var definition in scriptDefinitionMap.Values)
{
if (oldDefinitions.ContainsKey(definition.Guid))
{
var oldDefinition = oldDefinitions[definition.Guid];
var oldParentDefinition = (
from d in oldDefinitions.Values
where d.Children.Contains(oldDefinition)
select d
).FirstOrDefault();
if (oldParentDefinition != null)
{
if (scriptDefinitionMap.ContainsKey(oldParentDefinition.Guid))
{
var parentDefinition = scriptDefinitionMap[oldParentDefinition.Guid];
parentDefinition.Children.Add(definition);
continue;
}
}
}
ScriptDefinitions.Add(definition);
}
// フォルダ扱いになったスクリプト定義とリンクしたクラス定義が存在する場合、
// クラス定義のGUIDを再発行
{
var query1 = from sd in GetScriptDefinitionList()
where sd.IsFolder
select sd;
foreach (var sd in query1)
{
var scriptDefinition = sd;
var query2 = from cd in ClassDefinitions
where cd.Guid == scriptDefinition.Guid
select cd;
foreach (var cd in query2)
{
var classDefinition = cd;
int oldGuid = classDefinition.Guid;
classDefinition.Guid = NewScriptGuid();
if (console != null) {
console.WriteLine("スクリプトフォルダとクラス定義のGUIDが重複したため、クラス定義のGUIDを変更します");
console.WriteLine(
"{0} {1} -> {2}",
classDefinition.FullName,
oldGuid,
classDefinition.Guid
);
}
}
}
}
if (console != null) console.WriteLine("========== インポート完了: {0} Files ==========", fileCount);
}
/// <summary>
/// スクリプト定義の親情報をプロジェクトから検索する。
/// </summary>
/// <param name="definition">スクリプト定義のインスタンス。</param>
/// <returns>条件に該当するスクリプト定義。</returns>
public ScriptDefinition FindParentScriptDefinition(ScriptDefinition definition)
{
var query = from d in GetScriptDefinitionList()
where d.Children.Contains(definition)
select d;
return query.FirstOrDefault();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="sd"></param>
public CsScriptRuntime(ScriptDefinition sd) : base(sd)
{
}
public CsScriptRuntimeGeneric(ScriptDefinition sd)
{
_sd = sd;
}
/// <summary>
/// スクリプト定義にクラス定義とのリンクが存在するかチェックする。
/// </summary>
/// <param name="scriptDefinition">スクリプト定義のインスタンス。</param>
/// <returns></returns>
public bool ExistsClassLink(ScriptDefinition scriptDefinition)
{
return (
from d in ClassDefinitions
where d.Guid == scriptDefinition.Guid
select d
).Count() > 0;
}
/// <summary>
/// ノードにスクリプト定義の内容を反映する。
/// </summary>
/// <param name="definition">スクリプト定義のインスタンス。</param>
public void Refresh(ScriptDefinition definition)
{
Text = definition.DisplayName;
Tag = definition;
if (definition.IsFolder)
{
ImageKey = "FolderIconClosed.ico";
}
else
{
ImageKey = "ScriptIcon.ico";
}
SelectedImageKey = ImageKey;
Nodes.Clear();
foreach (var child in definition.Children)
{
Nodes.Add(ScriptTreeNode.Create(child));
}
}
/// <summary>
/// スクリプトエディタをコントローラへ登録し、開く。
/// </summary>
/// <param name="definition">スクリプト定義のインスタンス。</param>
/// <param name="parameters">固有パラメータ。</param>
private void RegisterScriptEditor(ScriptDefinition definition)
{
ScriptEditorTab tab = FindScriptEditor(definition);
if (tab != null)
{
tab.Activate();
return;
}
tab = new ScriptEditorTab();
tab.Parameters = new KeyValueMap();
tab.Parameters["Project"] = Project;
tab.Definition = definition;
tab.FormClosed += ScriptEditor_FormClosed;
tab.Apply += ScriptEditor_Apply;
MainForm.ShowContent(tab, DockState.Document);
}
/// <summary>
/// スクリプトノードのリフレッシュを行う。
/// </summary>
/// <param name="definition">スクリプト定義のインスタンス。</param>
private void RefreshScriptNode(ScriptDefinition definition)
{
if (ProjectExplorer != null)
{
ProjectExplorer.RefreshScriptNode(definition);
}
}
// Return the file path for the script specified.
private string GetScriptFile(ScriptDefinition d) => $"{_config.ScriptsDir}/{d.Name}.yml";
/// <summary>
/// すでに開かれているスクリプトエディタを検索する。
/// </summary>
/// <param name="definition">定義情報のインスタンス。</param>
/// <param name="parameters">パラメータ。</param>
/// <returns>スクリプトエディタが開かれていればエディタのインスタンス。</returns>
private ScriptEditorTab FindScriptEditor(ScriptDefinition definition)
{
return MainForm.FindScriptEditor(definition);
}
/// <summary>
/// スクリプト定義クリアの再帰処理。
/// </summary>
/// <param name="definitions">スクリプト定義のDictionary。</param>
/// <param name="definition">スクリプト定義のインスタンス。</param>
private void ClearScriptDefinitionsRecursive(
Dictionary<int, ScriptDefinition> definitions,
ScriptDefinition definition)
{
definitions.Add(definition.Guid, definition);
// 旧ファイルを削除
if (!definition.IsFolder)
{
var scriptFilePath = GetScriptFullPath(definition.FileName);
if (File.Exists(scriptFilePath)) File.Delete(scriptFilePath);
}
foreach (var child in definition.Children)
{
ClearScriptDefinitionsRecursive(definitions, child);
}
}
