コード例 #1
0
        private void FormatPropertyChange(PSWhatIfPropertyChange propertyChange, int maxPathLength, int indentLevel)
        {
            //this.FormatHead(propertyChange, maxPathLength, indentLevel);

            PropertyChangeType             propertyChangeType = propertyChange.PropertyChangeType;
            string                         path     = propertyChange.Path;
            JToken                         before   = propertyChange.Before;
            JToken                         after    = propertyChange.After;
            IList <PSWhatIfPropertyChange> children = propertyChange.Children;

            switch (propertyChange.PropertyChangeType)
            {
            case PropertyChangeType.Create:
                this.FormatPropertyChangePath(propertyChangeType, path, after, children, maxPathLength, indentLevel);
                this.FormatPropertyCreate(after, indentLevel + 1);
                break;

            case PropertyChangeType.Delete:
                this.FormatPropertyChangePath(propertyChangeType, path, before, children, maxPathLength, indentLevel);
                this.FormatPropertyDelete(before, indentLevel + 1);
                break;

            case PropertyChangeType.Modify:
                this.FormatPropertyChangePath(propertyChangeType, path, before, children, maxPathLength, indentLevel);
                this.FormatPropertyModify(propertyChange, indentLevel + 1);
                break;

            case PropertyChangeType.Array:
                this.FormatPropertyArrayChange(propertyChange.Children, indentLevel + 1);
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
        }
コード例 #2
0
        private void FormatPropertyModify(PSWhatIfPropertyChange propertyChange, int indentLevel)
        {
            if (propertyChange.Children != null)
            {
                // Has nested changes.
                this.Builder.AppendLine().AppendLine();
                this.FormatPropertyChanges(propertyChange.Children
                                           .OrderBy(pc => pc.PropertyChangeType, new PropertyChangeTypeComparer())
                                           .ThenBy(pc => pc.Path)
                                           .ToList(),
                                           indentLevel);
            }
            else
            {
                JToken before = propertyChange.Before;
                JToken after  = propertyChange.After;

                // The before value.
                this.FormatPropertyDelete(before, indentLevel);

                // Space before =>
                if (before.IsNonEmptyObject())
                {
                    this.Builder
                    .AppendLine()
                    .Append(Indent(indentLevel));
                }
                else
                {
                    this.Builder.Append(Symbol.WhiteSpace);
                }

                // =>
                this.Builder.Append("=>");

                // Space after =>
                if (!after.IsNonEmptyObject())
                {
                    this.Builder.Append(Symbol.WhiteSpace);
                }

                // The after value.
                this.FormatPropertyCreate(after, indentLevel);

                if (!before.IsLeaf() && after.IsLeaf())
                {
                    this.Builder.AppendLine();
                }
            }
        }
コード例 #3
0
        private static bool ShouldConsiderPathLength(PSWhatIfPropertyChange propertyChange)
        {
            switch (propertyChange.PropertyChangeType)
            {
            case PropertyChangeType.Create:
                return(propertyChange.After.IsLeaf());

            case PropertyChangeType.Delete:
            case PropertyChangeType.Modify:
                return(propertyChange.Before.IsLeaf());

            default:
                return(propertyChange.Children == null || propertyChange.Children.Count == 0);
            }
        }