Exemplo n.º 1
0
        public void SetAddInSetting(StyleCopAddIn addIn, PropertyValue property)
        {
            Param.RequireNotNull(addIn, "addIn");
            Param.RequireNotNull(property, "property");

            this.SetAddInSettingInternal(addIn, property);
        }
Exemplo n.º 2
0
        /// <summary>
        /// Saves a single property value.
        /// </summary>
        /// <param name="rootCollectionNode">The collection node containing the property.</param>
        /// <param name="property">The property to save.</param>
        /// <param name="propertyName">The name of the property.</param>
        /// <returns>Returns true if the property was saved; otherwise false.</returns>
        private static bool SavePropertyValue(XmlNode rootCollectionNode, PropertyValue property, string propertyName)
        {
            Param.AssertNotNull(rootCollectionNode, "rootCollectionNode");
            Param.AssertNotNull(property, "property");
            Param.AssertValidString(propertyName, "propertyName");

            bool propertyWritten = false;

            switch (property.PropertyType)
            {
                case PropertyType.Boolean:
                    propertyWritten |= SaveBooleanProperty(rootCollectionNode, property as BooleanProperty, propertyName);
                    break;

                case PropertyType.Int:
                    propertyWritten |= SaveIntProperty(rootCollectionNode, property as IntProperty, propertyName);
                    break;

                case PropertyType.String:
                    propertyWritten |= SaveStringProperty(rootCollectionNode, property as StringProperty, propertyName);
                    break;

                case PropertyType.Collection:
                    propertyWritten |= SaveCollectionProperty(rootCollectionNode, property as CollectionProperty, propertyName);
                    break;

                default:
                    Debug.Fail("Unexpected property type.");
                    break;
            }

            return propertyWritten;
        }
Exemplo n.º 3
0
        /// <summary>
        /// Saves a rule property.
        /// </summary>
        /// <param name="rootNode">The node to store the property collection beneath.</param>
        /// <param name="property">The property to save.</param>
        /// <param name="ruleName">The name of the rule.</param>
        /// <param name="propertyName">The name of the property.</param>
        /// <returns>Returns true if the property was saved; otherwise false.</returns>
        private static bool SaveRuleProperty(XmlNode rootNode, PropertyValue property, string ruleName, string propertyName)
        {
            Param.AssertNotNull(rootNode, "rootNode");
            Param.AssertNotNull(property, "property");
            Param.AssertValidString(ruleName, "ruleName");
            Param.AssertValidString(propertyName, "propertyName");

            // Get or create the Rules node under the root.
            XmlNode rulesNode = rootNode.SelectSingleNode("Rules");
            if (rulesNode == null)
            {
                rulesNode = rootNode.OwnerDocument.CreateElement("Rules");
                rootNode.AppendChild(rulesNode);
            }

            // Get or create the Rule node.
            XmlNode ruleNode = rulesNode.SelectSingleNode("Rule[@Name=\"" + ruleName + "\"]");
            if (ruleNode == null)
            {
                ruleNode = rootNode.OwnerDocument.CreateElement("Rule");
                rulesNode.AppendChild(ruleNode);

                XmlAttribute attrib = rootNode.OwnerDocument.CreateAttribute("Name");
                attrib.Value = ruleName;
                ruleNode.Attributes.Append(attrib);
            }

            // Get or create the RuleSettings node.
            XmlNode ruleSettings = ruleNode.SelectSingleNode("RuleSettings");
            if (ruleSettings == null)
            {
                ruleSettings = rootNode.OwnerDocument.CreateElement("RuleSettings");
                ruleNode.AppendChild(ruleSettings);
            }

            // Save the setting.
            return SavePropertyValue(ruleSettings, property, propertyName);
        }
Exemplo n.º 4
0
        /// <summary>
        /// Determines whether the local property overrides the parent property.
        /// </summary>
        /// <param name="localProperty">The local property.</param>
        /// <param name="parentProperty">The parent property.</param>
        /// <returns>Returns true if the local property overrides the parent property.</returns>
        public static bool IsSettingOverwritten(PropertyValue localProperty, PropertyValue parentProperty)
        {
            Param.Ignore(localProperty, parentProperty);

            // If either the parent property or the local property is not set, then the setting is not overwritten.
            if (parentProperty == null || localProperty == null)
            {
                return false;
            }

            // Ensure that the two properties are the same kind of property.
            if (localProperty.PropertyType != parentProperty.PropertyType)
            {
                throw new ArgumentException(Strings.ComparingDifferentPropertyTypes);
            }

            return localProperty.OverridesProperty(parentProperty);
        }
Exemplo n.º 5
0
        /// <summary>
        /// Merges two collection properties together.
        /// </summary>
        /// <param name="mergedPropertyCollection">
        /// The merged property collection.
        /// </param>
        /// <param name="originalProperty">
        /// The original property to merge.
        /// </param>
        /// <param name="overridingProperty">
        /// The overriding property to merge.
        /// </param>
        private static void MergeCollectionProperties(PropertyCollection mergedPropertyCollection, PropertyValue originalProperty, PropertyValue overridingProperty)
        {
            Param.AssertNotNull(mergedPropertyCollection, "mergedPropertyCollection");
            Param.AssertNotNull(originalProperty, "originalProperty");
            Param.AssertNotNull(overridingProperty, "overridingProperty");

            CollectionProperty originalCollectionProperty = (CollectionProperty)originalProperty;
            CollectionProperty overridingCollectionProperty = (CollectionProperty)overridingProperty;

            // Create a new merged collection property.
            CollectionProperty mergedCollectionProperty = new CollectionProperty((CollectionPropertyDescriptor)originalCollectionProperty.PropertyDescriptor);
            mergedPropertyCollection.Add(mergedCollectionProperty);

            // Add each of the strings from the overriding collection.
            foreach (string value in overridingCollectionProperty.Values)
            {
                mergedCollectionProperty.Add(value);
            }

            // If necessary, also add the strings from the original collection.
            if (originalCollectionProperty.Aggregate)
            {
                foreach (string value in originalCollectionProperty.Values)
                {
                    if (!mergedCollectionProperty.Contains(value))
                    {
                        mergedCollectionProperty.Add(value);
                    }
                }
            }
        }
Exemplo n.º 6
0
        /// <summary>
        /// Determines whether the given global setting overrides the parent setting.
        /// </summary>
        /// <param name="propertyName">The name of the property.</param>
        /// <param name="localProperty">The local value of the property.</param>
        /// <returns>Returns true if the given global setting overrides the parent setting.</returns>
        public bool IsGlobalSettingOverwritten(string propertyName, PropertyValue localProperty)
        {
            Param.RequireValidString(propertyName, "propertyName");
            Param.Ignore(localProperty);

            if (this.parentSettings == null)
            {
                return false;
            }

            // Try to find this property in the parent settings file.
            PropertyValue parentProperty = this.parentSettings.GlobalSettings[propertyName];
            if (parentProperty == null)
            {
                return false;
            }

            return IsSettingOverwritten(localProperty, parentProperty);
        }
Exemplo n.º 7
0
        public bool IsAddInSettingOverwritten(StyleCopAddIn addIn, string propertyName, PropertyValue localProperty)
        {
            Param.RequireNotNull(addIn, "addIn");
            Param.RequireValidString(propertyName, "propertyName");
            Param.Ignore(localProperty);

            if (this.parentSettings == null)
            {
                return false;
            }

            // Try to find this property in the parent settings file.
            PropertyValue parentProperty = null;

            PropertyCollection parentParserProperties = this.parentSettings.GetAddInSettings(addIn);
            if (parentParserProperties != null)
            {
                parentProperty = parentParserProperties[propertyName];
            }

            if (parentProperty == null)
            {
                // If there is no parent setting, then the parent is set to the default. If the local setting
                // is not set to the default, then we consider that the local setting is overriding the parent setting.
                return !localProperty.HasDefaultValue || !localProperty.IsDefault;
            }

            // Compare the local and parent properties.
            return IsSettingOverwritten(localProperty, parentProperty);
        }
Exemplo n.º 8
0
        /// <summary>
        /// Sets the given property on the add-in.
        /// </summary>
        /// <param name="settings">The settings.</param>
        /// <param name="property">The property to set.</param>
        public void SetSetting(WritableSettings settings, PropertyValue property)
        {
            Param.RequireNotNull(settings, "settings");
            Param.RequireNotNull(property, "property");

            settings.SetAddInSetting(this, property);
        }
Exemplo n.º 9
0
 /// <summary>
 /// Determines whether this property overrides the given property.
 /// </summary>
 /// <param name="parentProperty">The parent property to compare with.</param>
 /// <returns>Returns true if this property overrides the given property.</returns>
 public abstract bool OverridesProperty(PropertyValue parentProperty);
        /// <summary>
        /// Sets a setting for the given add-in.
        /// </summary>
        /// <param name="addIn">
        /// The add-in. 
        /// </param>
        /// <param name="property">
        /// The setting property to set. 
        /// </param>
        internal void SetAddInSettingInternal(StyleCopAddIn addIn, PropertyValue property)
        {
            Param.AssertNotNull(addIn, "addIn");
            Param.AssertNotNull(property, "property");

            AddInPropertyCollection properties = this.GetAddInSettings(addIn);
            if (properties == null)
            {
                properties = new AddInPropertyCollection(addIn);
                this.SetAddInSettings(properties);
            }

            properties.Add(property);
        }
Exemplo n.º 11
0
        /// <summary>
        /// Saves the given property collection.
        /// </summary>
        /// <param name="rootNode">
        /// The node to store the property collection beneath.
        /// </param>
        /// <param name="nodeName">
        /// The name of the new property collection node.
        /// </param>
        /// <param name="properties">
        /// The property collection to store.
        /// </param>
        /// <param name="parentProperties">
        /// The corresponding property collection from the parent settings, if any.
        /// </param>
        /// <param name="aggregate">
        /// Indicates whether the collection is aggregated with the parent collection.
        /// </param>
        /// <param name="nodeNameAttribute">
        /// An optional name attribute value for the new property node.
        /// </param>
        /// <returns>
        /// Returns true if at least one property was saved.
        /// </returns>
        private static bool SavePropertyCollection(
            XmlNode rootNode, string nodeName, PropertyCollection properties, PropertyCollection parentProperties, bool aggregate, string nodeNameAttribute)
        {
            Param.AssertNotNull(rootNode, "rootNode");
            Param.AssertValidString(nodeName, "nodeName");
            Param.AssertNotNull(properties, "properties");
            Param.Ignore(parentProperties);
            Param.Ignore(aggregate);
            Param.Ignore(nodeNameAttribute);

            // If there are no properties in the collection, don't save anything.
            if (properties.Count == 0)
            {
                return(false);
            }

            bool propertyWritten = false;

            // Create the root node for this property collection.
            Debug.Assert(rootNode.OwnerDocument != null, "The root node has not been attached to a document.");
            XmlElement rootCollectionNode = rootNode.OwnerDocument.CreateElement(nodeName);

            if (!string.IsNullOrEmpty(nodeNameAttribute))
            {
                XmlAttribute rootCollectionNodeNameAttribute = rootNode.OwnerDocument.CreateAttribute("Name");
                rootCollectionNodeNameAttribute.Value = nodeNameAttribute;
                rootCollectionNode.Attributes.Append(rootCollectionNodeNameAttribute);
            }

            // Add each property in the collection.
            foreach (PropertyValue property in properties)
            {
                bool          skip           = false;
                PropertyValue parentProperty = null;

                if (parentProperties != null)
                {
                    parentProperty = parentProperties[property.PropertyName];

                    // If the property also exists in the parent collection, determine whether the local property
                    // is an override. If not, there is no need to add it.
                    if (aggregate && parentProperty != null)
                    {
                        if (!SettingsComparer.IsSettingOverwritten(property, parentProperty))
                        {
                            skip = true;
                        }
                    }
                    else if (property.IsDefault)
                    {
                        skip = true;
                    }
                }
                else if (property.IsDefault)
                {
                    skip = true;
                }

                if (!skip)
                {
                    // If the property is a rule setting, then add it under the rules section.
                    int index = property.PropertyName.IndexOf('#');
                    if (index > 0)
                    {
                        propertyWritten |= SaveRuleProperty(
                            rootNode,
                            property,
                            property.PropertyName.Substring(0, index),
                            property.PropertyName.Substring(index + 1, property.PropertyName.Length - index - 1));
                    }
                    else
                    {
                        // Just save the property value under this add-in's settings since it is
                        // not a rule property.
                        propertyWritten |= SavePropertyValue(rootCollectionNode, property, property.PropertyName);
                    }
                }
            }

            // If at least one property was saved, add the property collection node into the document.
            if (propertyWritten)
            {
                rootNode.AppendChild(rootCollectionNode);
            }

            return(propertyWritten);
        }
Exemplo n.º 12
0
 /// <summary>
 /// Determines whether this property overrides the given property.
 /// </summary>
 /// <param name="parentProperty">The parent property to compare with.</param>
 /// <returns>Returns true if this property overrides the given property.</returns>
 public abstract bool OverridesProperty(PropertyValue parentProperty);