Пример #1
0
        public static bool IsResponseValueMatch(VariableAssignmentLine currentLineAsAssignmentLine, VariableAssignmentLine responseValueAssignmentToAnotherVariable)
        {
            var variableName = currentLineAsAssignmentLine.VariableName + ".Value";

            if (variableName == responseValueAssignmentToAnotherVariable.AssignedValue)
            {
                return(true);
            }

            if (responseValueAssignmentToAnotherVariable.AssignedValue.StartsWith(variableName + "."))
            {
                var extraExtension = responseValueAssignmentToAnotherVariable.AssignedValue.RemoveFromStart(variableName);

                if (!currentLineAsAssignmentLine.AssignedValue.EndsWith(extraExtension))
                {
                    currentLineAsAssignmentLine.AssignedValue += extraExtension;
                }

                return(true);
            }

            return(false);
        }
Пример #2
0
        public static VariableAssignmentLine Parse(string line)
        {
            if (line == null)
            {
                return(null);
            }

            var arr = line.Split('=');

            if (arr.Length < 2)
            {
                return(null);
            }

            var namePart = arr[0]?.Trim().Split(' ').Where(x => !string.IsNullOrWhiteSpace(x)).ToArray();

            VariableAssignmentLine variableAssignmentLine = null;

            if (namePart?.Length == 1)
            {
                variableAssignmentLine = new VariableAssignmentLine
                {
                    VariableName = namePart[0]
                };
            }
            else if (namePart?.Length == 2)
            {
                variableAssignmentLine = new VariableAssignmentLine
                {
                    VariableName     = namePart[1],
                    VariableTypeName = namePart[0]
                };
            }
            else
            {
                return(null);
            }

            var items = new List <string>();

            for (var i = 1; i < arr.Length; i++)
            {
                items.Add(arr[i].Trim());
            }

            var valuePart = string.Join(" = ", items).Trim();

            if (string.IsNullOrWhiteSpace(valuePart))
            {
                return(null);
            }

            if (valuePart.EndsWith(";") == false)
            {
                return(null);
            }

            variableAssignmentLine.AssignedValue = valuePart.Substring(0, valuePart.Length - 1);

            return(variableAssignmentLine);
        }
Пример #3
0
        public static void Parse(RegionParserData data)
        {
            var lineCount = data.LineCount;

            for (var i = 0; i < lineCount; i++)
            {
                if (i + 4 >= lineCount)
                {
                    continue;
                }

                var nextLineText    = data[i + 1]?.Replace(" ", string.Empty);
                var isResponseCheck = nextLineText?.StartsWith("if(!") == true && nextLineText.EndsWith(".Success)");

                var LineNumber = data.GetLineNumber(i);

                if (isResponseCheck)
                {
                    //var response = bo.call();
                    //if (!response.Success)
                    //{
                    //    return returnObject.Add(response);       -> var x = bo.call();
                    //}
                    // var x = response.Value;

                    var leftBracketOffset = 2;
                    if (data[i + leftBracketOffset]?.Trim() != "{")
                    {
                        continue;
                    }

                    var rightBracketOffset = 4;

                    // returnObject.Results.AddRange(responseAcc.Results);
                    if (IsAddingResultToReturnObject(data[i + leftBracketOffset + 1]) &&
                        data[i + leftBracketOffset + 2]?.Trim() == "return returnObject;" &&
                        data[i + leftBracketOffset + 3]?.Trim() == "}")
                    {
                        rightBracketOffset = leftBracketOffset + 3;
                    }
                    else if (data[i + leftBracketOffset + 1]?.Trim().StartsWith("return returnObject") == true &&
                             data[i + leftBracketOffset + 2]?.Trim() == "}")
                    {
                        rightBracketOffset = leftBracketOffset + 2;
                    }
                    else if (data[i + leftBracketOffset + 1]?.Trim().StartsWith("Context.AddResult(") == true &&
                             data[i + leftBracketOffset + 2]?.Trim() == "return;" &&
                             data[i + leftBracketOffset + 3]?.Trim() == "}")
                    {
                        rightBracketOffset = leftBracketOffset + 3;
                    }

                    else
                    {
                        continue;
                    }

                    var firstChar = data[i + 1].First(c => c != ' ');

                    var firstCharIndex = data[i + 1].IndexOf(firstChar);

                    var currentLine = data[i];

                    var currentLineAsAssignmentLine = VariableAssignmentLine.Parse(currentLine);
                    if (currentLineAsAssignmentLine == null)
                    {
                        continue;
                    }

                    VariableAssignmentLine responseValueAssignmentToAnotherVariable = null;

                    // walk empty lines
                    var endOfEmptyLinesOffset = rightBracketOffset + 1;
                    if (rightBracketOffset < lineCount - 1)
                    {
                        while (true)
                        {
                            if (i + endOfEmptyLinesOffset >= lineCount)
                            {
                                break;
                            }

                            if (!string.IsNullOrEmpty(data[i + endOfEmptyLinesOffset]))
                            {
                                break;
                            }

                            endOfEmptyLinesOffset++;
                        }

                        responseValueAssignmentToAnotherVariable = VariableAssignmentLine.Parse(data[i + endOfEmptyLinesOffset]);
                    }


                    if (responseValueAssignmentToAnotherVariable != null && VariableAssignmentLine.IsResponseValueMatch(currentLineAsAssignmentLine, responseValueAssignmentToAnotherVariable))
                    {
                        var sb = new StringBuilder();
                        if (responseValueAssignmentToAnotherVariable.VariableTypeName != null)
                        {
                            sb.Append(responseValueAssignmentToAnotherVariable.VariableTypeName);
                            sb.Append(" ");
                        }

                        sb.Append(responseValueAssignmentToAnotherVariable.VariableName);

                        sb.Append(" = ");

                        sb.Append(currentLineAsAssignmentLine.AssignedValue);
                        sb.Append(";");

                        data.Regions.Add(new Region
                        {
                            StartLine   = LineNumber,
                            StartOffset = firstCharIndex,
                            EndLine     = data.GetLineNumber(i + endOfEmptyLinesOffset),
                            Text        = sb.ToString()
                        });

                        i = i + endOfEmptyLinesOffset;
                        continue;
                    }

                    data.Regions.Add(new Region
                    {
                        StartLine   = LineNumber,
                        StartOffset = firstCharIndex,
                        EndLine     = data.GetLineNumber(i + rightBracketOffset),
                        Text        = currentLineAsAssignmentLine.AssignedValue + ";"
                    });

                    i = i + rightBracketOffset;
                }
            }
        }