Exemplo n.º 1
0
        protected virtual IEnumerable <XmlConnectionGroup> ReadConnectionGroup(ComponentDescription description, XElement connectionGroupElement, XmlConnectionGroup parentGroup)
        {
            IConditionTreeItem conditionCollection = ConditionTree.Empty;
            var conditionsAttribute = connectionGroupElement.Attribute("conditions");

            if (conditionsAttribute != null)
            {
                if (!conditionParser.Parse(conditionsAttribute, description, logger, out conditionCollection))
                {
                    yield break;
                }
            }

            var connectionGroup = new XmlConnectionGroup(new ConditionTree(ConditionTree.ConditionOperator.AND, parentGroup.Conditions, conditionCollection));

            autoRotateOptionsReader.TrySetAutoRotateOptions(connectionGroupElement, parentGroup, connectionGroup);

            var childGroups = connectionGroupElement.Elements().SelectMany(x => ReadElement(x, description, connectionGroup));

            yield return(connectionGroup);

            foreach (var child in childGroups)
            {
                yield return(child);
            }
        }
        public void ReadSection(XElement connectionsElement, ComponentDescription description)
        {
            List <ConnectionGroup> parsedConnectionGroups = new List <ConnectionGroup>();
            var connectionGroupNodes = connectionsElement.Elements(XmlLoader.ComponentNamespace + "group");

            foreach (var connectionGroupNode in connectionGroupNodes)
            {
                IConditionTreeItem           conditionCollection = ConditionTree.Empty;
                List <ConnectionDescription> connections         = new List <ConnectionDescription>();

                var conditionsAttribute = connectionGroupNode.Attribute("conditions");
                if (conditionsAttribute != null)
                {
                    if (!conditionParser.Parse(conditionsAttribute, description, logger, out conditionCollection))
                    {
                        continue;
                    }
                }

                foreach (var connectionNode in connectionGroupNode.Elements(XmlLoader.ComponentNamespace + "connection"))
                {
                    ConnectionEdge edge = ConnectionEdge.None;
                    if (connectionNode.Attribute("edge") != null)
                    {
                        string edgeText = connectionNode.Attribute("edge").Value.ToLowerInvariant();
                        if (edgeText == "start")
                        {
                            edge = ConnectionEdge.Start;
                        }
                        else if (edgeText == "end")
                        {
                            edge = ConnectionEdge.End;
                        }
                        else if (edgeText == "both")
                        {
                            edge = ConnectionEdge.Both;
                        }
                    }
                    string connectionName = "#";
                    if (connectionNode.Attribute("name") != null)
                    {
                        connectionName = connectionNode.Attribute("name").Value;
                    }

                    if (!componentPointParser.TryParse(connectionNode.Attribute("start"), out var start) ||
                        !componentPointParser.TryParse(connectionNode.Attribute("end"), out var end))
                    {
                        continue;
                    }

                    connections.Add(new ConnectionDescription(start, end, edge, connectionName));
                }

                parsedConnectionGroups.Add(new ConnectionGroup(conditionCollection, connections.ToArray()));
            }

            description.Connections = parsedConnectionGroups.ToArray();
        }
Exemplo n.º 3
0
        protected virtual RenderDescription ReadRenderGroup(ComponentDescription description, XElement renderNode)
        {
            IConditionTreeItem conditionCollection = ConditionTree.Empty;
            var conditionsAttribute = renderNode.Attribute("conditions");

            if (conditionsAttribute != null)
            {
                if (!conditionParser.Parse(conditionsAttribute, description, logger, out conditionCollection))
                {
                    return(null);
                }
            }

            var commands = new List <IRenderCommand>();

            foreach (var renderCommandNode in renderNode.Descendants())
            {
                string commandType = renderCommandNode.Name.LocalName;
                if (commandType == "line")
                {
                    if (ReadLineCommand(renderCommandNode, out var command))
                    {
                        commands.Add(command);
                    }
                }
                else if (commandType == "rect")
                {
                    if (ReadRectCommand(renderCommandNode, out var command))
                    {
                        commands.Add(command);
                    }
                }
                else if (commandType == "ellipse")
                {
                    if (ReadEllipseCommand(description.Metadata.FormatVersion, renderCommandNode, out var command))
                    {
                        commands.Add(command);
                    }
                }
                else if (commandType == "text")
                {
                    if (ReadTextCommand(renderCommandNode, description, out var command))
                    {
                        commands.Add(command);
                    }
                }
                else if (commandType == "path")
                {
                    if (ReadPathCommand(renderCommandNode, out var command))
                    {
                        commands.Add(command);
                    }
                }
            }

            return(new RenderDescription(conditionCollection, commands.ToArray()));
        }
Exemplo n.º 4
0
    public IAttribute?Parse(XmlReader reader, IParsingContext parsingContext)
    {
        var result = conditionParser.Parse(reader.Value);

        if (result.Condition is not null)
        {
            return(new WhenAttribute(result.Condition));
        }

        parsingContext.LogError(reader, "Condição 'when' inválida. " + result.Message);
        return(null);
    }
Exemplo n.º 5
0
    public async Task ShouldUpdateParentContextEnabledWhen()
    {
        var reader  = A.Dummy <XmlReader>();
        var context = A.Fake <IParsingContext>(i => i.Strict());

        var parsedCondition = A.Dummy <IParsedCondition>();

        A.CallTo(() => conditionParser.Parse("condição")).Returns(parsedCondition);

        var optionNode = A.Fake <IChoiceOptionNodeSetter>(i => i.Strict());

        A.CallToSet(() => optionNode.EnabledWhen).To(parsedCondition.Condition).DoesNothing();

        var parentContext = A.Fake <IChoiceOptionParentParsingContext>(i => i.Strict());

        A.CallTo(() => parentContext.Option).Returns(optionNode);

        A.CallTo(() => elementParser.ParseAsync(reader, context, A <IParentParsingContext> .Ignored, sut.Settings))
        .Invokes(i => i.GetArgument <IParentParsingContext>(2).ParsedText = "condição");

        await sut.ParseAsync(reader, context, parentContext);

        A.CallToSet(() => optionNode.EnabledWhen).To(parsedCondition.Condition).MustHaveHappenedOnceExactly();
    }
Exemplo n.º 6
0
        public IConditionTreeItem Parse(ComponentDescription description, string input)
        {
            var version = description.Metadata.FormatVersion;

            if (version < new Version(1, 1))
            {
                return(new LegacyConditionParser(description).Parse(description, input));
            }

            if (version == new Version(1, 1))
            {
                return(parserV11.Parse(description, input));
            }

            return(parserLatest.Parse(description, input));
        }
Exemplo n.º 7
0
 public static bool Parse(this IConditionParser parser, XAttribute conditionsAttribute, ComponentDescription description, IXmlLoadLogger logger, out IConditionTreeItem value)
 {
     try
     {
         value = parser.Parse(description, conditionsAttribute.Value);
         return(true);
     }
     catch (ConditionFormatException ex)
     {
         IXmlLineInfo line     = conditionsAttribute;
         int          startCol = line.LinePosition + conditionsAttribute.Name.LocalName.Length + 2 + ex.PositionStart;
         var          position = new FileRange(line.LineNumber, startCol, line.LineNumber, startCol + ex.Length);
         logger.Log(LogLevel.Error, position, ex.Message, null);
         value = null;
         return(false);
     }
 }
Exemplo n.º 8
0
    public async Task ParseAsync(XmlReader reader, IParsingContext parsingContext, IParentParsingContext parentParsingContext)
    {
        var myContext = new TextParentParsingContext();
        await elementParser.ParseAsync(reader, parsingContext, myContext, Settings);

        if (myContext.ParsedText is null)
        {
            return;
        }

        var result = conditionParser.Parse(myContext.ParsedText);

        if (result.Condition is null)
        {
            parsingContext.LogError(reader, "Condição EnabledWhen inválida. " + result.Message);
            return;
        }
        var ctx = (IChoiceOptionParentParsingContext)parentParsingContext;

        ctx.Option.EnabledWhen = result.Condition;
    }
        public void ReadSection(XElement element, ComponentDescription description)
        {
            var definitions = new Dictionary <string, ConditionalCollection <string> >();

            foreach (var definitionNode in element.Elements(XmlLoader.ComponentNamespace + "def"))
            {
                if (!definitionNode.GetAttributeValue("name", logger, out var name))
                {
                    continue;
                }

                var values = new ConditionalCollection <string>();
                foreach (var valueWhen in definitionNode.Elements(XmlLoader.ComponentNamespace + "when"))
                {
                    valueWhen.GetAttribute("conditions", logger, out var conditionsAttribute);
                    valueWhen.GetAttributeValue("value", logger, out var whenValue);
                    conditionParser.Parse(conditionsAttribute, description, logger, out var conditions);

                    values.Add(new Conditional <string>(whenValue, conditions));
                }

                definitions.Add(name, values);
            }

            foreach (var constNode in element.Elements(XmlLoader.ComponentNamespace + "const"))
            {
                if (!constNode.GetAttributeValue("name", logger, out var name) ||
                    !constNode.GetAttributeValue("value", logger, out var value))
                {
                    continue;
                }

                var values = new ConditionalCollection <string>();
                values.Add(new Conditional <string>(value, ConditionTree.Empty));

                definitions.Add(name, values);
            }

            sectionRegistry.RegisterSection(new DefinitionsSection(definitions));
        }
Exemplo n.º 10
0
        protected IEnumerable <RenderDescription> ReadRenderDescriptions(ComponentDescription description, XElement renderNode)
        {
            IConditionTreeItem conditionCollection = ConditionTree.Empty;
            var conditionsAttribute = renderNode.Attribute("conditions");

            if (conditionsAttribute != null)
            {
                if (!conditionParser.Parse(conditionsAttribute, description, logger, out conditionCollection))
                {
                    yield break;
                }
            }

            var declaredDefinitions  = new List <string>();
            var whenDefinedAttribute = renderNode.Attribute("whenDefined");

            if (whenDefinedAttribute != null)
            {
                var usedVariables = whenDefinedAttribute.Value.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
                declaredDefinitions.AddRange(usedVariables.Select(x => x.Substring(1)));
            }
            var allUndefined = declaredDefinitions.Except(availableDefinitions).ToHashSet();

            if (allUndefined.Any())
            {
                foreach (var undefined in allUndefined)
                {
                    logger.LogError(whenDefinedAttribute, $"Usage of undefined variable: ${undefined}");
                }
                yield break;
            }

            var commands = new List <IRenderCommand>();

            foreach (var renderCommandNode in renderNode.Descendants())
            {
                string commandType = renderCommandNode.Name.LocalName;
                if (commandType == "line")
                {
                    foreach (var renderLineDescription in ReadLineCommand(renderCommandNode, conditionCollection, declaredDefinitions))
                    {
                        yield return(renderLineDescription);
                    }
                }
                else if (commandType == "rect")
                {
                    foreach (var renderRectDescription in ReadRectCommand(renderCommandNode, conditionCollection, declaredDefinitions))
                    {
                        yield return(renderRectDescription);
                    }
                }
                else if (commandType == "ellipse")
                {
                    if (ReadEllipseCommand(description.Metadata.Version, renderCommandNode, out var command))
                    {
                        commands.Add(command);
                    }
                }
                else if (commandType == "text")
                {
                    foreach (var renderTextDescription in ReadTextCommand(renderCommandNode, description, conditionCollection, declaredDefinitions))
                    {
                        yield return(renderTextDescription);
                    }
                }
                else if (commandType == "path")
                {
                    if (ReadPathCommand(renderCommandNode, out var command))
                    {
                        commands.Add(command);
                    }
                }
            }

            yield return(new RenderDescription(conditionCollection, commands.ToArray()));
        }
        private ComponentProperty ReadPropertyNode(ComponentDescription description, XElement propertyElement)
        {
            string propertyName = propertyElement.Attribute("name").Value;
            string type         = propertyElement.Attribute("type").Value;
            string defaultValue = propertyElement.Attribute("default").Value;
            string serializeAs  = propertyElement.Attribute("serialize").Value;
            string display      = propertyElement.Attribute("display").Value;

            PropertyType propertyType;

            switch (type.ToLowerInvariant())
            {
            case "double":
            // TODO: Add warning
            case "decimal":
                propertyType = PropertyType.Decimal;
                break;

            case "int":
                propertyType = PropertyType.Integer;
                break;

            case "bool":
                propertyType = PropertyType.Boolean;
                break;

            default:
                propertyType = PropertyType.String;
                break;
            }

            var propertyDefaultValue = PropertyValue.Parse(defaultValue, propertyType.ToPropertyType());

            List <string> propertyOptions = null;

            if (type == "enum")
            {
                propertyOptions = new List <string>();
                var optionNodes = propertyElement.Elements(propertyElement.GetDefaultNamespace() + "option");
                foreach (var optionNode in optionNodes)
                {
                    propertyOptions.Add(optionNode.Value);
                }
            }

            List <ComponentPropertyFormat> formatRules = new List <ComponentPropertyFormat>();

            if (propertyElement.Attribute("format") != null)
            {
                formatRules.Add(new ComponentPropertyFormat(propertyElement.Attribute("format").Value, ConditionTree.Empty));
            }
            else
            {
                var formatRuleNodes = propertyElement.Elements(propertyElement.GetDefaultNamespace() + "formatting")
                                      .SelectMany(x => x.Elements(propertyElement.GetDefaultNamespace() + "format"));
                foreach (var formatNode in formatRuleNodes)
                {
                    IConditionTreeItem conditionCollection = ConditionTree.Empty;

                    var conditionsAttribute = formatNode.Attribute("conditions");
                    if (conditionsAttribute != null)
                    {
                        conditionParser.Parse(conditionsAttribute, description, logger, out conditionCollection);
                    }

                    formatRules.Add(new ComponentPropertyFormat(formatNode.Attribute("value").Value, conditionCollection));
                }
            }

            Dictionary <PropertyOtherConditionType, IConditionTreeItem> otherConditions = new Dictionary <PropertyOtherConditionType, IConditionTreeItem>();
            var otherConditionsNodes = propertyElement.Elements(propertyElement.GetDefaultNamespace() + "other")
                                       .SelectMany(x => x.Elements(propertyElement.GetDefaultNamespace() + "conditions"));

            foreach (var otherConditionNode in otherConditionsNodes)
            {
                if (otherConditionNode?.Attribute("for") != null && otherConditionNode.Attribute("value") != null)
                {
                    string conditionsFor = otherConditionNode.Attribute("for").Value;
                    if (!conditionParser.Parse(otherConditionNode.Attribute("value"), description, logger, out var conditionCollection))
                    {
                        continue;
                    }

                    if (Enum.IsDefined(typeof(PropertyOtherConditionType), conditionsFor))
                    {
                        otherConditions.Add((PropertyOtherConditionType)Enum.Parse(typeof(PropertyOtherConditionType), conditionsFor, true), conditionCollection);
                    }
                }
            }

            ComponentProperty property = new ComponentProperty(propertyName, serializeAs, display, propertyType, propertyDefaultValue, formatRules.ToArray(), otherConditions, (propertyOptions == null ? null : propertyOptions.ToArray()));

            return(property);
        }