protected string stLastCommand(IPM pm)
{
if (!IsAvaialbleCommandEvent)
{
throw new NotSupportedOperationException("CommandEvents: aren't available for current context. Use full environment.");
}
if (pm.FinalEmptyIs(LevelType.Property, "Guid"))
{
return((lastCommandEvent.Guid) ?? Value.Empty);
}
if (pm.FinalEmptyIs(LevelType.Property, "Id"))
{
return(Value.from(lastCommandEvent.Id));
}
if (pm.FinalEmptyIs(LevelType.Property, "CustomIn"))
{
return(Value.pack(lastCommandEvent.CustomIn) ?? Value.Empty);
}
if (pm.FinalEmptyIs(LevelType.Property, "CustomOut"))
{
return(Value.pack(lastCommandEvent.CustomOut) ?? Value.Empty);
}
if (pm.FinalEmptyIs(LevelType.Property, "Pre"))
{
return(Value.from(lastCommandEvent.Pre)); // see commandEvent below
}
throw new IncorrectNodeException(pm);
}
protected string stHash(IPM pm)
{
if (!pm.It(LevelType.Property, "hash"))
{
throw new IncorrectNodeException(pm);
}
ILevel lvlHash = pm.FirstLevel; // level of the hash property
// hash.MD5("data")
if (pm.FinalEmptyIs(LevelType.Method, "MD5"))
{
lvlHash.Is("hash.MD5(string data)", ArgumentType.StringDouble);
return(((string)lvlHash.Args[0].data).MD5Hash());
}
// hash.SHA1("data")
if (pm.FinalEmptyIs(LevelType.Method, "SHA1"))
{
lvlHash.Is("hash.SHA1(string data)", ArgumentType.StringDouble);
return(((string)lvlHash.Args[0].data).SHA1Hash());
}
throw new IncorrectNodeException(pm);
}
/// <param name="pm"></param>
/// <returns></returns>
protected string StCallFamily(IPM pm)
{
if (pm.FinalEmptyIs(LevelType.Method, "call"))
{
return(StCall(pm, false, false));
}
if (pm.FinalEmptyIs(LevelType.Method, "out"))
{
return(StCall(pm, true, true)); // redirect to sout
}
if (pm.FinalEmptyIs(LevelType.Method, "scall"))
{
return(StCall(pm, false, true));
}
if (pm.FinalEmptyIs(LevelType.Method, "sout"))
{
return(StCall(pm, true, true));
}
if (pm.FinalEmptyIs(LevelType.Method, "cmd"))
{
return(StCmd(pm));
}
throw new IncorrectNodeException(pm);
}
protected string StExists(IPM pm)
{
if (!pm.It(LevelType.Property, "exists"))
{
throw new IncorrectNodeException(pm);
}
ILevel level = pm.FirstLevel;
if (!pm.FinalEmptyIs(LevelType.Method, "directory") &&
!pm.FinalEmptyIs(LevelType.Method, "file"))
{
throw new IncorrectNodeException(pm);
}
if (level.Is(ArgumentType.StringDouble))
{
return(StExists(pm.IsData("file"), (string)level.Args[0].data, false));
}
if (level.Is(ArgumentType.StringDouble, ArgumentType.Boolean))
{
return(StExists(pm.IsData("file"), (string)level.Args[0].data, (bool)level.Args[1].data));
}
throw new PMLevelException(level, level.Data + "(string path [, boolean environment])");
}
protected string StLastCommand(IPM pm)
{
if (!env.IsAvaialbleDteCmd)
{
throw new NotSupportedOperationException("DTE commands aren't available for current context. Use full environment.");
}
if (pm.FinalEmptyIs(LevelType.Property, "Guid"))
{
return((env.LastCmd.Guid) ?? Value.Empty);
}
if (pm.FinalEmptyIs(LevelType.Property, "Id"))
{
return(Value.From(env.LastCmd.Id));
}
if (pm.FinalEmptyIs(LevelType.Property, "CustomIn"))
{
return(Value.Pack(env.LastCmd.CustomIn) ?? Value.Empty);
}
if (pm.FinalEmptyIs(LevelType.Property, "CustomOut"))
{
return(Value.Pack(env.LastCmd.CustomOut) ?? Value.Empty);
}
if (pm.FinalEmptyIs(LevelType.Property, "Pre"))
{
return(Value.From(env.LastCmd.Pre));
}
throw new IncorrectNodeException(pm);
}
protected string stData(IPM pm)
{
if (!pm.It(LevelType.Property, "data"))
{
throw new IncorrectNodeException(pm);
}
ILevel level = pm.FirstLevel;
if (pm.FinalIs(LevelType.Method, "pack"))
{
return(dataPack(level, pm));
}
if (pm.FinalEmptyIs(LevelType.Method, "free"))
{
return(dataFree(level, pm));
}
if (pm.FinalEmptyIs(LevelType.Method, "get"))
{
return(dataGet(level, pm));
}
if (pm.FinalEmptyIs(LevelType.Method, "clone"))
{
return(dataClone(level, pm));
}
throw new IncorrectNodeException(pm);
}
protected string StReplace(IPM pm)
{
SearchType type = SearchType.Null;
// old signatures
if (pm.FinalEmptyIs(LevelType.Method, "replace"))
{
// replace(...)
type = SearchType.Basic;
}
else if (pm.It(LevelType.Property, "replace"))
{
if (pm.FinalEmptyIs(LevelType.Method, "Regex") || pm.FinalEmptyIs(LevelType.Method, "Regexp"))
{
// replace.Regex(...) & replace.Regexp(...)
type = SearchType.Regexp;
}
else if (pm.FinalEmptyIs(LevelType.Method, "Wildcards"))
{
// replace.Wildcards(...)
type = SearchType.Wildcards;
}
}
if (type == SearchType.Null)
{
throw new IncorrectNodeException(pm);
}
// arguments
ILevel level = pm.FirstLevel;
if (!level.Is(ArgumentType.StringDouble, ArgumentType.StringDouble, ArgumentType.StringDouble))
{
throw new PMLevelException(level, "(string file, string pattern, string replacement)");
}
string file = GetLocation((string)level.Args[0].data);
string pattern = (string)level.Args[1].data;
string replacement = (string)level.Args[2].data;
LSender.Send(this, $"StReplace: found file '{file}', pattern '{pattern}', replacement '{replacement}'", MsgLevel.Trace);
Encoding enc = DetectEncodingFromFile(file);
string content = ReadToEnd(file, enc);
LSender.Send(this, $"StReplace: type '{type}' :: received '{content.Length}', Encoding '{enc}'");
content = StReplaceEngine(type, ref content, pattern, replacement);
WriteToFile(file, content, false, enc);
return(Value.Empty);
}
protected string mActionRun(SolutionEventType type, ISolutionEvent evt, IPM pm)
{
if (!pm.FinalEmptyIs(LevelType.Method, "run"))
{
throw new IncorrectNodeException(pm);
}
ILevel level = pm.FirstLevel;
BuildType buildType;
if (level.Args == null || level.Args.Count < 1)
{
buildType = BuildType.Common;
}
else if (level.Is(ArgumentType.EnumOrConst))
{
buildType = (BuildType)Enum.Parse(typeof(BuildType), (string)level.Args[0].data);
}
else
{
throw new PMLevelException(level, "run([enum context])");
}
ICommand cmd = new Actions.Command(env, soba, emsbuild);
Log.Info($"Execute action by user-script: '{evt.Name}'(context: {buildType}) /as '{type}' event");
cmd.Env.BuildType = buildType;
return(Value.From(cmd.exec(evt, type)));
}
protected string stCheck(IPM pm)
{
if (pm.FinalEmptyIs(LevelType.Method, "check"))
{
return(check(pm.FirstLevel, pm));
}
throw new IncorrectNodeException(pm);
}
protected string pStdout(ISolutionEvent evt, IPM pm)
{
if (pm.FinalEmptyIs(LevelType.RightOperandEmpty))
{
return(Value.from(HProcess.Stdout(evt.Id)));
}
throw new IncorrectNodeException(pm);
}
protected string pStderr(ISolutionEvent evt, IPM pm)
{
if (pm.FinalEmptyIs(LevelType.RightOperandEmpty))
{
return(Value.From(Exer?.PullStdErr(evt.Id)));
}
throw new IncorrectNodeException(pm);
}
protected string StCopy(IPM pm)
{
if (!pm.It(LevelType.Property, "copy"))
{
throw new IncorrectNodeException(pm);
}
ILevel level = pm.FirstLevel;
if (pm.FinalEmptyIs(LevelType.Method, "file"))
{
return(CopyFile(level, pm));
}
if (pm.FinalEmptyIs(LevelType.Method, "directory"))
{
return(CopyDirectory(level, pm));
}
throw new IncorrectNodeException(pm);
}
protected string StDelete(IPM pm)
{
if (!pm.It(LevelType.Property, "delete"))
{
throw new IncorrectNodeException(pm);
}
ILevel level = pm.FirstLevel;
if (pm.FinalEmptyIs(LevelType.Method, "files"))
{
return(DeleteFiles(level, pm));
}
if (pm.FinalEmptyIs(LevelType.Method, "directory"))
{
return(DeleteDirectory(level, pm));
}
throw new IncorrectNodeException(pm);
}
protected string stUnpack(IPM pm)
{
if (pm.FinalEmptyIs(LevelType.Method, "unpack"))
{
return(unpack(pm.FirstLevel, pm));
}
//TODO: ~ unpack.files(...)
throw new IncorrectNodeException(pm);
}
protected string stPack(IPM pm)
{
if (!pm.It(LevelType.Property, "pack"))
{
throw new IncorrectNodeException(pm);
}
ILevel level = pm.FirstLevel; // level of the pack property
if (pm.FinalEmptyIs(LevelType.Method, "files"))
{
return(packFiles(level, pm));
}
if (pm.FinalEmptyIs(LevelType.Method, "directory"))
{
return(packDirectory(level, pm));
}
throw new IncorrectNodeException(pm);
}
protected string pEnabled(ISolutionEvent evt, IPM pm)
{
if (pm.FinalEmptyIs(LevelType.RightOperandEmpty))
{
return(Value.From(evt.Enabled));
}
evt.Enabled = Value.ToBoolean(pm.FirstLevel.Data);
Log.Trace($"pEnabled: updated status '{evt.Enabled}' for '{evt.Name}'");
return(Value.Empty);
}
private protected string UseProjectsMap(ProjectItem project, IPM pm)
{
if (pm.FinalEmptyIs(LevelType.Property, "name"))
{
return(project.name);
}
if (pm.FinalEmptyIs(LevelType.Property, "path"))
{
return(project.path);
}
if (pm.FinalEmptyIs(LevelType.Property, "type"))
{
return(project.type);
}
if (pm.FinalEmptyIs(LevelType.Property, "guid"))
{
return(project.guid);
}
throw new IncorrectNodeException(pm);
}
protected string StGet(IPM pm)
{
if (!pm.FinalEmptyIs(LevelType.Method, "get"))
{
throw new IncorrectNodeException(pm);
}
ILevel level = pm.FirstLevel;
if (!level.Is(ArgumentType.StringDouble))
{
throw new PMLevelException(level, "get(string name)");
}
string file = GetLocation((string)level.Args[0].data);
return(ReadToEnd(file, DetectEncodingFromFile(file)));
// NOTE: x NotFoundException -> FileNotFoundException
}
protected string stRaise(IPM pm)
{
if (!pm.FinalEmptyIs(0, LevelType.Method, "raise"))
{
throw new OperationNotFoundException("stRaise: not found - '{0}' /'{1}'", pm.Levels[1].Data, pm.Levels[1].Type);
}
Argument[] args = pm.Levels[0].Args;
if (args.Length != 4 ||
args[0].type != ArgumentType.StringDouble ||
args[1].type != ArgumentType.Integer)
{
throw new InvalidArgumentException("stRaise: incorrect arguments to `raise(string guid, integer id, mixed customIn, mixed customOut)`");
}
string guid = (string)args[0].data;
int id = (int)args[1].data;
object customIn;
if (args[2].type == ArgumentType.Object)
{
customIn = (object)Value.extract((Argument[])args[2].data);
}
else
{
customIn = args[2].data;
}
object customOut;
if (args[3].type == ArgumentType.Object)
{
customOut = (object)Value.extract((Argument[])args[3].data);
}
else
{
customOut = args[3].data;
}
Log.Trace("stRaise: guid - '{0}', id - '{1}', In - '{2}', Out - '{3}' ", guid, id, customIn, customOut);
raise(guid, id, ref customIn, ref customOut);
return(Value.Empty);
}
protected string stGNT(IPM pm)
{
if (!pm.Is(LevelType.Property, "gnt"))
{
throw new IncorrectNodeException(pm);
}
ILevel level = pm.Levels[1]; // level of the gnt property
if (pm.FinalEmptyIs(1, LevelType.Method, "raw"))
{
return(rawMethod(level, pm));
}
// TODO: +gnt.get(object list [, string path [, string server]]) + config files
// +gnt.pack(string nuspec [, string path])
throw new IncorrectNodeException(pm, 1);
}
protected string stOperators(IPM pm)
{
if (!pm.It(LevelType.Property, "operators"))
{
throw new IncorrectNodeException(pm);
}
ILevel lvlOp = pm.FirstLevel;
if (pm.FinalEmptyIs(LevelType.Method, "sleep"))
{
lvlOp.Is("sleep(integer timeout)", ArgumentType.Integer);
Thread.Sleep((int)lvlOp.Args[0].data);
return(String.Empty);
}
throw new IncorrectNodeException(pm);
}
protected string itemStatus(SolutionEventType type, int index, IPM pm)
{
if (!pm.Is(LevelType.Property, "Status"))
{
throw new IncorrectNodeException(pm);
}
if (pm.FinalEmptyIs(1, LevelType.Property, "HasErrors"))
{
string status = Value.From(Status._.get(type, index) == StatusType.Fail);
#if DEBUG
Log.Trace($"pStatus: status - '{status}'");
#endif
return(status);
}
throw new IncorrectNodeException(pm, 1);
}
protected string stSlnPMap(string sln, IPM pm)
{
if (String.IsNullOrWhiteSpace(sln))
{
throw new InvalidArgumentException("Failed stSlnPMap: sln is empty");
}
ProjectsMap map = getProjectsMap(sln);
if (pm.Is(LevelType.Property, "First"))
{
return(projectsMap(map.FirstBy(env.BuildType), pm.pinTo(1)));
}
if (pm.Is(LevelType.Property, "Last"))
{
return(projectsMap(map.LastBy(env.BuildType), pm.pinTo(1)));
}
if (pm.Is(LevelType.Property, "FirstRaw"))
{
return(projectsMap(map.First, pm.pinTo(1)));
}
if (pm.Is(LevelType.Property, "LastRaw"))
{
return(projectsMap(map.Last, pm.pinTo(1)));
}
if (pm.FinalEmptyIs(LevelType.Property, "GuidList"))
{
return(Value.from(map.GuidList));
}
if (pm.Is(LevelType.Method, "projectBy"))
{
ILevel lvlPrjBy = pm.FirstLevel;
lvlPrjBy.Is("projectBy(string guid)", ArgumentType.StringDouble);
return(projectsMap(map.getProjectBy((string)lvlPrjBy.Args[0].data), pm.pinTo(1)));
}
throw new IncorrectNodeException(pm);
}
protected string StSlnPMap(string sln, IPM pm)
{
if (string.IsNullOrWhiteSpace(sln))
{
throw new ArgumentException($"Failed {nameof(StSlnPMap)}: sln is empty");
}
ProjectsMap map = GetProjectsMap(sln);
if (pm.Is(LevelType.Property, "First"))
{
return(UseProjectsMap(map.FirstBy(env.IsCleanOperation), pm.PinTo(1)));
}
if (pm.Is(LevelType.Property, "Last"))
{
return(UseProjectsMap(map.LastBy(env.IsCleanOperation), pm.PinTo(1)));
}
if (pm.Is(LevelType.Property, "FirstRaw"))
{
return(UseProjectsMap(map.First, pm.PinTo(1)));
}
if (pm.Is(LevelType.Property, "LastRaw"))
{
return(UseProjectsMap(map.Last, pm.PinTo(1)));
}
if (pm.FinalEmptyIs(LevelType.Property, "GuidList"))
{
return(Value.From(map.GuidList));
}
if (pm.Is(LevelType.Method, "projectBy"))
{
ILevel lvlPrjBy = pm.FirstLevel;
lvlPrjBy.Is("projectBy(string guid)", ArgumentType.StringDouble);
return(UseProjectsMap(map.GetProjectBy((string)lvlPrjBy.Args[0].data), pm.PinTo(1)));
}
throw new IncorrectNodeException(pm);
}
protected string StRemote(IPM pm)
{
if (!pm.It(LevelType.Property, "remote"))
{
throw new IncorrectNodeException(pm);
}
ILevel level = pm.FirstLevel;
if (pm.FinalEmptyIs(LevelType.Method, "download"))
{
if (level.Is(ArgumentType.StringDouble, ArgumentType.StringDouble))
{
return(Download((string)level.Args[0].data, (string)level.Args[1].data));
}
if (level.Is(ArgumentType.StringDouble, ArgumentType.StringDouble, ArgumentType.StringDouble, ArgumentType.StringDouble))
{
return(Download((string)level.Args[0].data, (string)level.Args[1].data, (string)level.Args[2].data, (string)level.Args[3].data));
}
throw new PMLevelException(level, "(string addr, string output [, string user, string pwd])");
}
throw new IncorrectNodeException(pm);
}
protected string stRemote(IPM pm)
{
if(!pm.It(LevelType.Property, "remote")) {
throw new IncorrectNodeException(pm);
}
ILevel level = pm.FirstLevel;
if(pm.FinalEmptyIs(LevelType.Method, "download"))
{
if(level.Is(ArgumentType.StringDouble, ArgumentType.StringDouble)) {
return download((string)level.Args[0].data, (string)level.Args[1].data);
}
if(level.Is(ArgumentType.StringDouble, ArgumentType.StringDouble, ArgumentType.StringDouble, ArgumentType.StringDouble)) {
return download((string)level.Args[0].data, (string)level.Args[1].data, (string)level.Args[2].data, (string)level.Args[3].data);
}
throw new ArgumentPMException(level, "(string addr, string output [, string user, string pwd])");
}
throw new IncorrectNodeException(pm);
}
protected string stGNT(IPM pm)
{
if(!pm.Is(LevelType.Property, "gnt")) {
throw new IncorrectNodeException(pm);
}
ILevel level = pm.Levels[1]; // level of the gnt property
if(pm.FinalEmptyIs(1, LevelType.Method, "raw")) {
return rawMethod(level, pm);
}
// TODO: +gnt.get(object list [, string path [, string server]]) + config files
// +gnt.pack(string nuspec [, string path])
throw new IncorrectNodeException(pm, 1);
}
protected string stCopy(IPM pm)
{
if(!pm.It(LevelType.Property, "copy")) {
throw new IncorrectNodeException(pm);
}
ILevel level = pm.FirstLevel;
if(pm.FinalEmptyIs(LevelType.Method, "file")) {
return copyFile(level, pm);
}
if(pm.FinalEmptyIs(LevelType.Method, "directory")) {
return copyDirectory(level, pm);
}
throw new IncorrectNodeException(pm);
}
protected string pStdout(ISolutionEvent evt, IPM pm)
{
if(pm.FinalEmptyIs(LevelType.RightOperandEmpty)) {
return Value.from(HProcess.Stdout(evt.Id));
}
throw new IncorrectNodeException(pm);
}
protected string projectsMap(ProjectsMap.Project project, IPM pm)
{
if(pm.FinalEmptyIs(LevelType.Property, "name")) {
return project.name;
}
if(pm.FinalEmptyIs(LevelType.Property, "path")) {
return project.path;
}
if(pm.FinalEmptyIs(LevelType.Property, "type")) {
return project.type;
}
if(pm.FinalEmptyIs(LevelType.Property, "guid")) {
return project.guid;
}
throw new IncorrectNodeException(pm);
}
protected string stOperators(IPM pm)
{
if(!pm.It(LevelType.Property, "operators")) {
throw new IncorrectNodeException(pm);
}
ILevel lvlOp = pm.FirstLevel;
if(pm.FinalEmptyIs(LevelType.Method, "sleep"))
{
lvlOp.Is("sleep(integer timeout)", ArgumentType.Integer);
Thread.Sleep((int)lvlOp.Args[0].data);
return String.Empty;
}
throw new IncorrectNodeException(pm);
}
protected string stData(IPM pm)
{
if(!pm.It(LevelType.Property, "data")) {
throw new IncorrectNodeException(pm);
}
ILevel level = pm.FirstLevel;
if(pm.FinalIs(LevelType.Method, "pack")) {
return dataPack(level, pm);
}
if(pm.FinalEmptyIs(LevelType.Method, "free")) {
return dataFree(level, pm);
}
if(pm.FinalEmptyIs(LevelType.Method, "get")) {
return dataGet(level, pm);
}
if(pm.FinalEmptyIs(LevelType.Method, "clone")) {
return dataClone(level, pm);
}
throw new IncorrectNodeException(pm);
}
protected string stReplace(IPM pm)
{
SearchType type = SearchType.Null;
// the old signatures
if(pm.FinalEmptyIs(LevelType.Method, "replace")) {
// replace(...)
type = SearchType.Basic;
}
else if(pm.It(LevelType.Property, "replace"))
{
if(pm.FinalEmptyIs(LevelType.Method, "Regex") || pm.FinalEmptyIs(LevelType.Method, "Regexp")) {
// replace.Regex(...) & replace.Regexp(...)
type = SearchType.Regexp;
}
else if(pm.FinalEmptyIs(LevelType.Method, "Wildcards")) {
// replace.Wildcards(...)
type = SearchType.Wildcards;
}
}
if(type == SearchType.Null) {
throw new IncorrectNodeException(pm);
}
// arguments
ILevel level = pm.FirstLevel;
if(!level.Is(ArgumentType.StringDouble, ArgumentType.StringDouble, ArgumentType.StringDouble)) {
throw new ArgumentPMException(level, "(string file, string pattern, string replacement)");
}
string file = location((string)level.Args[0].data);
string pattern = (string)level.Args[1].data;
string replacement = (string)level.Args[2].data;
Log.Trace("stReplace: found file '{0}', pattern '{1}', replacement '{2}'", file, pattern, replacement);
Encoding enc = detectEncodingFromFile(file);
string content = readToEnd(file, enc);
Log.Debug("stReplace: type '{0}' :: received '{1}', Encoding '{2}'", type, content.Length, enc);
content = stReplaceEngine(type, ref content, pattern, replacement);
writeToFile(file, content, false, enc);
return Value.Empty;
}
protected string projectsMap(ProjectsMap.Project project, IPM pm)
{
if(pm.FinalEmptyIs(0, LevelType.Property, "name")) {
return project.name;
}
if(pm.FinalEmptyIs(0, LevelType.Property, "path")) {
return project.path;
}
if(pm.FinalEmptyIs(0, LevelType.Property, "type")) {
return project.type;
}
if(pm.FinalEmptyIs(0, LevelType.Property, "guid")) {
return project.guid;
}
throw new OperationNotFoundException("Failed projectsMap - '{0}' /'{1}'", pm.Levels[0].Data, pm.Levels[0].Type);
}
protected string stPack(IPM pm)
{
if(!pm.It(LevelType.Property, "pack")) {
throw new IncorrectNodeException(pm);
}
ILevel level = pm.FirstLevel; // level of the pack property
if(pm.FinalEmptyIs(LevelType.Method, "files")) {
return packFiles(level, pm);
}
if(pm.FinalEmptyIs(LevelType.Method, "directory")) {
return packDirectory(level, pm);
}
throw new IncorrectNodeException(pm);
}
protected string stGet(IPM pm)
{
if(!pm.FinalEmptyIs(LevelType.Method, "get")) {
throw new IncorrectNodeException(pm);
}
ILevel level = pm.FirstLevel;
if(!level.Is(ArgumentType.StringDouble)) {
throw new ArgumentPMException(level, "get(string name)");
}
string file = location((string)level.Args[0].data);
try {
return readToEnd(file, detectEncodingFromFile(file));
}
catch(FileNotFoundException ex) {
throw new ScriptException("File '{0}' is not found :: `{1}`", file, ex.Message);
}
}
protected string stOut(IPM pm)
{
if (!pm.Is(LevelType.Property, "out") && !pm.Is(LevelType.Method, "out"))
{
throw new IncorrectNodeException(pm);
}
string item = Settings._.DefaultOWPItem; // by default for all
bool isGuid = false;
if (pm.Is(LevelType.Method, "out"))
{
ILevel lvlOut = pm.FirstLevel;
if (!lvlOut.Is(ArgumentType.StringDouble) &&
!lvlOut.Is(ArgumentType.StringDouble, ArgumentType.Boolean))
{
throw new InvalidArgumentException("Incorrect arguments to `out(string ident [, boolean isGuid])`");
}
Argument[] args = lvlOut.Args;
item = (string)args[0].data;
isGuid = (args.Length == 2)? (bool)args[1].data : false; // optional isGuid param
}
Log.Trace("stOut: out = item('{0}'), isGuid('{1}')", item, isGuid);
IItemEW ew = OWPItems._.getEW((isGuid)? new OWPIdent()
{
guid = item
} : new OWPIdent()
{
item = item
});
string raw = StringHandler.escapeQuotes(ew.Raw);
// #[OWP out.All] / #[OWP out] / #[OWP out("Build").All] / #[OWP out("Build")] ...
if (pm.FinalEmptyIs(1, LevelType.Property, "All") || pm.FinalEmptyIs(1, LevelType.RightOperandEmpty))
{
return(raw);
}
// #[OWP out.Warnings.Count] ...
if (pm.Is(1, LevelType.Property, "Warnings") && pm.FinalEmptyIs(2, LevelType.Property, "Count"))
{
return(Value.from(ew.WarningsCount));
}
// #[OWP out.Warnings.Codes] ...
if (pm.Is(1, LevelType.Property, "Warnings") && pm.FinalEmptyIs(2, LevelType.Property, "Codes"))
{
return(Value.from(ew.Warnings));
}
// #[OWP out.Warnings.Raw] / #[OWP out.Warnings] ...
if ((pm.Is(1, LevelType.Property, "Warnings") && pm.FinalEmptyIs(2, LevelType.Property, "Raw")) ||
pm.FinalEmptyIs(1, LevelType.Property, "Warnings"))
{
return((ew.IsWarnings)? raw : Value.Empty);
}
// #[OWP out.Errors.Count] ...
if (pm.Is(1, LevelType.Property, "Errors") && pm.FinalEmptyIs(2, LevelType.Property, "Count"))
{
return(Value.from(ew.ErrorsCount));
}
// #[OWP out.Errors.Codes] ...
if (pm.Is(1, LevelType.Property, "Errors") && pm.FinalEmptyIs(2, LevelType.Property, "Codes"))
{
return(Value.from(ew.Errors));
}
// #[OWP out.Errors.Raw] / #[OWP out.Errors] ...
if ((pm.Is(1, LevelType.Property, "Errors") && pm.FinalEmptyIs(2, LevelType.Property, "Raw")) ||
pm.FinalEmptyIs(1, LevelType.Property, "Errors"))
{
return((ew.IsErrors)? raw : Value.Empty);
}
throw new IncorrectNodeException(pm, 1);
}
protected string stExists(IPM pm)
{
if(!pm.It(LevelType.Property, "exists")) {
throw new IncorrectNodeException(pm);
}
ILevel level = pm.FirstLevel;
if(!pm.FinalEmptyIs(LevelType.Method, "directory")
&& !pm.FinalEmptyIs(LevelType.Method, "file"))
{
throw new IncorrectNodeException(pm);
}
if(level.Is(ArgumentType.StringDouble)) {
return stExists(pm.IsData("file"), (string)level.Args[0].data, false);
}
if(level.Is(ArgumentType.StringDouble, ArgumentType.Boolean)) {
return stExists(pm.IsData("file"), (string)level.Args[0].data, (bool)level.Args[1].data);
}
throw new ArgumentPMException(level, level.Data + "(string path [, boolean environment])");
}
protected string stLastCommand(IPM pm)
{
if(!IsAvaialbleCommandEvent) {
throw new NotSupportedOperationException("CommandEvents: aren't available for current context. Use full environment.");
}
if(pm.FinalEmptyIs(LevelType.Property, "Guid")) {
return (lastCommandEvent.Guid) ?? Value.Empty;
}
if(pm.FinalEmptyIs(LevelType.Property, "Id")) {
return Value.from(lastCommandEvent.Id);
}
if(pm.FinalEmptyIs(LevelType.Property, "CustomIn")) {
return Value.pack(lastCommandEvent.CustomIn) ?? Value.Empty;
}
if(pm.FinalEmptyIs(LevelType.Property, "CustomOut")) {
return Value.pack(lastCommandEvent.CustomOut) ?? Value.Empty;
}
if(pm.FinalEmptyIs(LevelType.Property, "Pre")) {
return Value.from(lastCommandEvent.Pre); // see commandEvent below
}
throw new IncorrectNodeException(pm);
}
protected string stSlnPMap(string sln, IPM pm)
{
if(String.IsNullOrWhiteSpace(sln)) {
throw new InvalidArgumentException("Failed stSlnPMap: sln is empty");
}
ProjectsMap map = getProjectsMap(sln);
if(pm.Is(LevelType.Property, "First")) {
return projectsMap(map.FirstBy(env.BuildType), pm.pinTo(1));
}
if(pm.Is(LevelType.Property, "Last")) {
return projectsMap(map.LastBy(env.BuildType), pm.pinTo(1));
}
if(pm.Is(LevelType.Property, "FirstRaw")) {
return projectsMap(map.First, pm.pinTo(1));
}
if(pm.Is(LevelType.Property, "LastRaw")) {
return projectsMap(map.Last, pm.pinTo(1));
}
if(pm.FinalEmptyIs(LevelType.Property, "GuidList")) {
return Value.from(map.GuidList);
}
if(pm.Is(LevelType.Method, "projectBy"))
{
ILevel lvlPrjBy = pm.FirstLevel;
lvlPrjBy.Is("projectBy(string guid)", ArgumentType.StringDouble);
return projectsMap(map.getProjectBy((string)lvlPrjBy.Args[0].data), pm.pinTo(1));
}
throw new IncorrectNodeException(pm);
}
protected string stCheck(IPM pm)
{
if(pm.FinalEmptyIs(LevelType.Method, "check")) {
return check(pm.FirstLevel, pm);
}
throw new IncorrectNodeException(pm);
}
protected string stDelete(IPM pm)
{
if(!pm.It(LevelType.Property, "delete")) {
throw new IncorrectNodeException(pm);
}
ILevel level = pm.FirstLevel;
if(pm.FinalEmptyIs(LevelType.Method, "files")) {
return deleteFiles(level, pm);
}
if(pm.FinalEmptyIs(LevelType.Method, "directory")) {
return deleteDirectory(level, pm);
}
throw new IncorrectNodeException(pm);
}
protected string pEnabled(ISolutionEvent evt, IPM pm)
{
if(pm.FinalEmptyIs(LevelType.RightOperandEmpty)) {
return Value.from(evt.Enabled);
}
evt.Enabled = Value.toBoolean(pm.FirstLevel.Data);
Log.Trace("pEnabled: updated status '{0}' for '{1}'", evt.Enabled, evt.Name);
return Value.Empty;
}
/// <param name="pm"></param>
/// <returns></returns>
protected string stCallFamily(IPM pm)
{
if(pm.FinalEmptyIs(LevelType.Method, "call")) {
return stCall(pm, false, false);
}
if(pm.FinalEmptyIs(LevelType.Method, "out")) {
//return stCall(pm, true, false); obsolete
return stCall(pm, true, true); // redirect to sout
}
if(pm.FinalEmptyIs(LevelType.Method, "scall")) {
return stCall(pm, false, true);
}
if(pm.FinalEmptyIs(LevelType.Method, "sout")) {
return stCall(pm, true, true);
}
if(pm.FinalEmptyIs(LevelType.Method, "cmd")) {
return stCmd(pm);
}
throw new IncorrectNodeException(pm);
}
protected string itemStatus(SolutionEventType type, int index, IPM pm)
{
if(!pm.Is(LevelType.Property, "Status")) {
throw new IncorrectNodeException(pm);
}
if(pm.FinalEmptyIs(1, LevelType.Property, "HasErrors"))
{
string status = Value.from(Status._.get(type, index) == StatusType.Fail);
#if DEBUG
Log.Trace("pStatus: status - '{0}'", status);
#endif
return status;
}
throw new IncorrectNodeException(pm, 1);
}
protected string stRaise(IPM pm)
{
if(!pm.FinalEmptyIs(0, LevelType.Method, "raise")) {
throw new OperationNotFoundException("stRaise: not found - '{0}' /'{1}'", pm.Levels[1].Data, pm.Levels[1].Type);
}
Argument[] args = pm.Levels[0].Args;
if(args.Length != 4
|| args[0].type != ArgumentType.StringDouble
|| args[1].type != ArgumentType.Integer)
{
throw new InvalidArgumentException("stRaise: incorrect arguments to `raise(string guid, integer id, mixed customIn, mixed customOut)`");
}
string guid = (string)args[0].data;
int id = (int)args[1].data;
object customIn;
if(args[2].type == ArgumentType.Object) {
customIn = (object)Value.extract((Argument[])args[2].data);
}
else {
customIn = args[2].data;
}
object customOut;
if(args[3].type == ArgumentType.Object) {
customOut = (object)Value.extract((Argument[])args[3].data);
}
else {
customOut = args[3].data;
}
Log.Trace("stRaise: guid - '{0}', id - '{1}', In - '{2}', Out - '{3}' ", guid, id, customIn, customOut);
raise(guid, id, ref customIn, ref customOut);
return Value.Empty;
}
protected string stUnpack(IPM pm)
{
if(pm.FinalEmptyIs(LevelType.Method, "unpack")) {
return unpack(pm.FirstLevel, pm);
}
//TODO: ~ unpack.files(...)
throw new IncorrectNodeException(pm);
}
protected string StOut(IPM pm)
{
if (!pm.Is(LevelType.Property, "out") && !pm.Is(LevelType.Method, "out"))
{
throw new IncorrectNodeException(pm);
}
string item = env.DefaultItem; // by default for all
bool isGuid = false;
if (pm.Is(LevelType.Method, "out"))
{
ILevel lvlOut = pm.FirstLevel;
if (!lvlOut.Is(ArgumentType.StringDouble) &&
!lvlOut.Is(ArgumentType.StringDouble, ArgumentType.Boolean))
{
throw new PMLevelException(lvlOut, "`out(string ident [, boolean isGuid])`");
}
var args = lvlOut.Args;
item = (string)args[0].data;
isGuid = args.Length == 2 ? (bool)args[1].data : false; // optional isGuid param
}
LSender.Send(this, $"StOut: out = item('{item}'), isGuid('{isGuid}')", MsgLevel.Trace);
IEWData ew = env.GetEWData(item, isGuid);
string raw = StringHandler.EscapeQuotes(ew.Raw);
// #[OWP out.All] / #[OWP out] / #[OWP out("Build").All] / #[OWP out("Build")] ...
if (pm.FinalEmptyIs(1, LevelType.Property, "All") || pm.FinalEmptyIs(1, LevelType.RightOperandEmpty))
{
return(raw);
}
// #[OWP out.Warnings.Count] ...
if (pm.Is(1, LevelType.Property, "Warnings") && pm.FinalEmptyIs(2, LevelType.Property, "Count"))
{
return(Value.From(ew.Warnings.Count));
}
// #[OWP out.Warnings.Codes] ...
if (pm.Is(1, LevelType.Property, "Warnings") && pm.FinalEmptyIs(2, LevelType.Property, "Codes"))
{
return(Value.From(ew.Warnings));
}
// #[OWP out.Warnings.Raw] / #[OWP out.Warnings] ...
if ((pm.Is(1, LevelType.Property, "Warnings") && pm.FinalEmptyIs(2, LevelType.Property, "Raw")) ||
pm.FinalEmptyIs(1, LevelType.Property, "Warnings"))
{
return(ew.Warnings.Count > 0 ? raw : Value.Empty);
}
// #[OWP out.Errors.Count] ...
if (pm.Is(1, LevelType.Property, "Errors") && pm.FinalEmptyIs(2, LevelType.Property, "Count"))
{
return(Value.From(ew.Errors.Count));
}
// #[OWP out.Errors.Codes] ...
if (pm.Is(1, LevelType.Property, "Errors") && pm.FinalEmptyIs(2, LevelType.Property, "Codes"))
{
return(Value.From(ew.Errors));
}
// #[OWP out.Errors.Raw] / #[OWP out.Errors] ...
if ((pm.Is(1, LevelType.Property, "Errors") && pm.FinalEmptyIs(2, LevelType.Property, "Raw")) ||
pm.FinalEmptyIs(1, LevelType.Property, "Errors"))
{
return(ew.Errors.Count > 0 ? raw : Value.Empty);
}
throw new IncorrectNodeException(pm, 1);
}
protected string stOut(IPM pm)
{
if(!pm.Is(LevelType.Property, "out") && !pm.Is(LevelType.Method, "out")) {
throw new IncorrectNodeException(pm);
}
string item = Settings._.DefaultOWPItem; // by default for all
bool isGuid = false;
if(pm.Is(LevelType.Method, "out"))
{
ILevel lvlOut = pm.FirstLevel;
if(!lvlOut.Is(ArgumentType.StringDouble)
&& !lvlOut.Is(ArgumentType.StringDouble, ArgumentType.Boolean))
{
throw new InvalidArgumentException("Incorrect arguments to `out(string ident [, boolean isGuid])`");
}
Argument[] args = lvlOut.Args;
item = (string)args[0].data;
isGuid = (args.Length == 2)? (bool)args[1].data : false; // optional isGuid param
}
Log.Trace("stOut: out = item('{0}'), isGuid('{1}')", item, isGuid);
IItemEW ew = OWPItems._.getEW((isGuid)? new OWPIdent() { guid = item } : new OWPIdent() { item = item });
string raw = StringHandler.escapeQuotes(ew.Raw);
// #[OWP out.All] / #[OWP out] / #[OWP out("Build").All] / #[OWP out("Build")] ...
if(pm.FinalEmptyIs(1, LevelType.Property, "All") || pm.FinalEmptyIs(1, LevelType.RightOperandEmpty)) {
return raw;
}
// #[OWP out.Warnings.Count] ...
if(pm.Is(1, LevelType.Property, "Warnings") && pm.FinalEmptyIs(2, LevelType.Property, "Count")) {
return Value.from(ew.WarningsCount);
}
// #[OWP out.Warnings.Codes] ...
if(pm.Is(1, LevelType.Property, "Warnings") && pm.FinalEmptyIs(2, LevelType.Property, "Codes")) {
return Value.from(ew.Warnings);
}
// #[OWP out.Warnings.Raw] / #[OWP out.Warnings] ...
if((pm.Is(1, LevelType.Property, "Warnings") && pm.FinalEmptyIs(2, LevelType.Property, "Raw"))
|| pm.FinalEmptyIs(1, LevelType.Property, "Warnings"))
{
return (ew.IsWarnings)? raw : Value.Empty;
}
// #[OWP out.Errors.Count] ...
if(pm.Is(1, LevelType.Property, "Errors") && pm.FinalEmptyIs(2, LevelType.Property, "Count")) {
return Value.from(ew.ErrorsCount);
}
// #[OWP out.Errors.Codes] ...
if(pm.Is(1, LevelType.Property, "Errors") && pm.FinalEmptyIs(2, LevelType.Property, "Codes")) {
return Value.from(ew.Errors);
}
// #[OWP out.Errors.Raw] / #[OWP out.Errors] ...
if((pm.Is(1, LevelType.Property, "Errors") && pm.FinalEmptyIs(2, LevelType.Property, "Raw"))
|| pm.FinalEmptyIs(1, LevelType.Property, "Errors"))
{
return (ew.IsErrors)? raw : Value.Empty;
}
throw new IncorrectNodeException(pm, 1);
}
protected string stSlnPMap(string sln, IPM pm)
{
if(String.IsNullOrWhiteSpace(sln)) {
throw new InvalidArgumentException("Failed stSlnPMap: sln is empty");
}
ProjectsMap map = getProjectsMap(sln);
if(pm.Is(0, LevelType.Property, "First")) {
return projectsMap(map.FirstBy(env.BuildType), pm.pinTo(1));
}
if(pm.Is(0, LevelType.Property, "Last")) {
return projectsMap(map.LastBy(env.BuildType), pm.pinTo(1));
}
if(pm.Is(0, LevelType.Property, "FirstRaw")) {
return projectsMap(map.First, pm.pinTo(1));
}
if(pm.Is(0, LevelType.Property, "LastRaw")) {
return projectsMap(map.Last, pm.pinTo(1));
}
if(pm.FinalEmptyIs(0, LevelType.Property, "GuidList")) {
return Value.from(map.GuidList);
}
if(pm.Is(0, LevelType.Method, "projectBy"))
{
Argument[] args = pm.Levels[0].Args;
if(args.Length != 1 || args[0].type != ArgumentType.StringDouble) {
throw new InvalidArgumentException("stSlnPMap: incorrect arguments to `projectBy(string guid)`");
}
return projectsMap(map.getProjectBy((string)args[0].data), pm.pinTo(1));
}
throw new OperationNotFoundException("stSlnPMap: not found - '{0}' /'{1}'", pm.Levels[0].Data, pm.Levels[0].Type);
}
protected string stHash(IPM pm)
{
if(!pm.It(LevelType.Property, "hash")) {
throw new IncorrectNodeException(pm);
}
ILevel lvlHash = pm.FirstLevel; // level of the hash property
// hash.MD5("data")
if(pm.FinalEmptyIs(LevelType.Method, "MD5")) {
lvlHash.Is("hash.MD5(string data)", ArgumentType.StringDouble);
return ((string)lvlHash.Args[0].data).MD5Hash();
}
// hash.SHA1("data")
if(pm.FinalEmptyIs(LevelType.Method, "SHA1")) {
lvlHash.Is("hash.SHA1(string data)", ArgumentType.StringDouble);
return ((string)lvlHash.Args[0].data).SHA1Hash();
}
throw new IncorrectNodeException(pm);
}