예제 #1
0
        public override void Modified(XElement source, XElement target, ApiChanges diff)
        {
            // hack - there could be changes that we're not monitoring (e.g. attributes properties)
            var output = Output;

            State.Output = new StringWriter();

            var sb = source.GetAttribute("base");
            var tb = target.GetAttribute("base");
            var rm = $"{State.Namespace}.{State.Type}: Modified base type: '{sb}' to '{tb}'";

            State.LogDebugMessage($"Possible -r value: {rm}");
            if (sb != tb &&
                !State.IgnoreRemoved.Any(re => re.IsMatch(rm)) &&
                !(State.IgnoreNonbreaking && IsBaseChangeCompatible(sb, tb)))
            {
                Formatter.BeginMemberModification(Output, "Modified base type");
                var apichange = new ApiChange($"{State.Namespace}.{State.Type}", State).AppendModified(sb, tb, true);
                Formatter.Diff(Output, apichange);
                Formatter.EndMemberModification(Output);
            }

            ccomparer.Compare(source, target);
            icomparer.Compare(source, target);
            fcomparer.Compare(source, target);
            pcomparer.Compare(source, target);
            ecomparer.Compare(source, target);
            mcomparer.Compare(source, target);

            var si = source.Element("classes");

            if (si != null)
            {
                var ti = target.Element("classes");
                kcomparer    = new NestedClassComparer(State);
                State.Parent = State.Type;
                kcomparer.Compare(si.Elements("class"), ti == null ? null : ti.Elements("class"));
                State.Type = State.Parent;
            }

            var s = (Output as StringWriter).ToString();

            State.Output = output;
            if (s.Length > 0)
            {
                SetContext(target);
                Formatter.BeginTypeModification(Output);
                Output.WriteLine(s);
                Formatter.EndTypeModification(Output);
            }
        }
예제 #2
0
        public void AddedInner(XElement target)
        {
            SetContext(target);
            if (target.IsTrue("serializable"))
            {
                Indent().WriteLine("[Serializable]");
            }

            var type = target.Attribute("type").Value;

            if (type == "enum")
            {
                // check if [Flags] is present
                var cattrs = target.Element("attributes");
                if (cattrs != null)
                {
                    foreach (var ca in cattrs.Elements("attribute"))
                    {
                        if (ca.GetAttribute("name") == "System.FlagsAttribute")
                        {
                            Indent().WriteLine("[Flags]");
                            break;
                        }
                    }
                }
            }

            Indent().Write("public");

            if (type != "enum")
            {
                bool seal = target.IsTrue("sealed");
                bool abst = target.IsTrue("abstract");
                if (seal && abst)
                {
                    Output.Write(" static");
                }
                else if (seal && type != "struct")
                {
                    Output.Write(" sealed");
                }
                else if (abst && type != "interface")
                {
                    Output.Write(" abstract");
                }
            }

            Output.Write(' ');
            Output.Write(type);
            Output.Write(' ');
            Output.Write(target.GetAttribute("name"));

            var baseclass = target.GetAttribute("base");

            if ((type != "enum") && (type != "struct"))
            {
                if (baseclass != null)
                {
                    if (baseclass == "System.Object")
                    {
                        // while true we do not need to be reminded every time...
                        baseclass = null;
                    }
                    else
                    {
                        Output.Write(" : ");
                        Output.Write(baseclass);
                    }
                }
            }

            // interfaces on enums are "standard" not user provided - so we do not want to show them
            if (type != "enum")
            {
                var i = target.Element("interfaces");
                if (i != null)
                {
                    var interfaces = new List <string> ();
                    foreach (var iface in i.Elements("interface"))
                    {
                        interfaces.Add(icomparer.GetDescription(iface));
                    }
                    Output.Write((baseclass == null) ? " : " : ", ");
                    Output.Write(String.Join(", ", interfaces));
                }
            }

            Output.WriteLine(" {");

            State.Indent++;
            var t = target.Element("constructors");

            if (t != null)
            {
                Indent().WriteLine("// constructors");
                foreach (var ctor in t.Elements("constructor"))
                {
                    ccomparer.Added(ctor, true);
                }
            }

            t = target.Element("fields");
            if (t != null)
            {
                if (type != "enum")
                {
                    Indent().WriteLine("// fields");
                }
                else
                {
                    SetContext(target);
                }
                foreach (var field in t.Elements("field"))
                {
                    fcomparer.Added(field, true);
                }
            }

            t = target.Element("properties");
            if (t != null)
            {
                Indent().WriteLine("// properties");
                foreach (var property in t.Elements("property"))
                {
                    pcomparer.Added(property, true);
                }
            }

            t = target.Element("events");
            if (t != null)
            {
                Indent().WriteLine("// events");
                foreach (var evnt in t.Elements("event"))
                {
                    ecomparer.Added(evnt, true);
                }
            }

            t = target.Element("methods");
            if (t != null)
            {
                Indent().WriteLine("// methods");
                foreach (var method in t.Elements("method"))
                {
                    mcomparer.Added(method, true);
                }
            }

            t = target.Element("classes");
            if (t != null)
            {
                Output.WriteLine();
                Indent().WriteLine("// inner types");
                State.Parent = State.Type;
                kcomparer    = new NestedClassComparer(State);
                foreach (var inner in t.Elements("class"))
                {
                    kcomparer.AddedInner(inner);
                }
                State.Type = State.Parent;
            }
            State.Indent--;
            Indent().WriteLine("}");
        }
예제 #3
0
 public NamespaceComparer(State state)
     : base(state)
 {
     comparer = new ClassComparer(state);
 }