Diff tool for XML files?

Question

I'm looking for a Windows-based diff tool that shows me the differences between two XML files, but does this tree-based, not line-based.
I.e. if a section has moved to a totally different place in the file it should not report differences.
These two files should be reported as 'the same':

<soapenv:Body>
  <mes:GetItem>
    <mes:ItemShape>
      <typ:BaseShape>IdOnly</typ:BaseShape>
      <typ:BodyType>Text</typ:BodyType>
      <typ:AdditionalProperties>
        <typ:FieldURI FieldURI="item:Subject" />
        <typ:FieldURI FieldURI="item:Categories" />
      </typ:AdditionalProperties>
    </mes:ItemShape>
    <mes:ItemIds>
      <typ:ItemId Id="AAMYAAA="/>
    </mes:ItemIds>
  </mes:GetItem>
</soapenv:Body>


<soapenv:Body>
  <mes:GetItem>
    <mes:ItemIds>
      <typ:ItemId Id="AAMYAAA="/>
    </mes:ItemIds>
    <mes:ItemShape>
      <typ:BodyType>Text</typ:BodyType>
      <typ:BaseShape>IdOnly</typ:BaseShape>
      <typ:AdditionalProperties>
        <typ:FieldURI FieldURI="item:Categories" />
        <typ:FieldURI FieldURI="item:Subject" />
      </typ:AdditionalProperties>
    </mes:ItemShape>
  </mes:GetItem>
</soapenv:Body>

And of course, all differences should be marked, preferably in a side-by-side view with indicators or lines connecting the sections that differ.

Free would be nice.
Optionaly ignoring name spaces would be nice.

Answer 1

Technically, XMLs are different

• if they have whitespaces or not
• if the order is different
• if they have comments or not
• if they have processing instructions or not
• if their encoding is different
• if their namespaces are different

but of course you can decide to ignore that or not, based on the semantic information an XML does not have.

Microsoft has developed the XML Diff and Patch tool for this purpose and you can integrate it in your own applications.

Note: the tool installs as "SQLXML Bulkload in .NET Code Sample" and comes with a Visual Studio solution XmlDiffView.sln that you need to compile yourself. Some basic programming knowledge in C# and Visual Studio Community Edition should be ok.

However, as mentioned in one of the answers on Stack Overflow, it has been compiled and made available on Bitbucket.

After that it comes with a UI that let's you choose the various XML comparison options:

When I apply it to the 2 XMLs of your questions, it throws an exception. That is because of the namespaces which are not defined. After removing the namespaces, it says:

Answer 2

Focusing on the part that moved sections should be reported as no difference made me think of https://semanticmerge.com/, which doesn't compare XML-files, but C# and C code. And as it understand those languages it is able to display if code has moved and not changed.

This leads to an alternative approach for this question: Could it be possible to translate the XML into C# classes, and then do a semantic merge on the resulting code?

One possible approach, if this tool is not written already, could be to translate each and every element to classes, and each attribute (and body texts) to a string property within that class. If you want to ignore namespaces, then let your translator remove them in the translation process.

I translated the XML example given as proof of concept and got the following:

class soapenv__Body {
  class mes__GetItem {
    class mes__ItemShape {
      class typ__BaseShape {
          string body="IdOnly";
      }
      class typ__BodyType {
          string body="Textus";
      }
      class typ__AdditionalProperties {
        class typ__FieldURI  {
            string FieldURI="item:Subject";
        }
        class typ__FieldURI  {
            string FieldURI="item:Categories"; 
        }
      }
    }
    class mes__ItemIds {
      class typ__ItemId {
          string Id="AAMYAAA=";
      }
    }
  }
}

Then I switched the mes:ItemIds and mes:ItemShape and changed the text to Textus. Compared the following two files in Semantic Merge and got the following image:

In this image one can see the move, indicated by the M icon, and the change in text indicated by the C icon. Lines indicates where the different parts have moved/changed, and it possible to actually see the differences if they exist.

Note that Semantic Merge even though understanding C# code, isn't to strict on the identical class names of typ__FieldURI, which could be a nice features as XML can contain multiple nodes with the same name.

Summa summarum: Semantic Merge can correctly identify the XML as identical (or not) even though elements move, if you can convert the XML into a C# class structure.

Answer 3

Technically those aren't the same (at least in xml), order does matter unless that is made explicit in the schema.

A combination of xmlstarlet and normal line-based utilities can make the problem much more tractable.

The following only compares the structure, but could be extended to look at the attributes,their values, and text

xmlstarlet el snippet1-with-namespaces.xml | sort > structure1.txt

xmlstarlet el snippet2-with-namespaces.xml | sort > structure2.txt

diff structure.txt structure2.txt

After running this on your snippets the diff shows no differences but there was some error text about namespaces (which would be safe to ignore).

Answer 4

I would recommend a tool XiMpLe which is primary the XML editor but it's also able to compare (and merge) xml files in a well arranged way. Your example is compared and evaluated as identical. There is also option to resolve namespaces as well.

Answer 5

Currently I am trying to solve a quite similar problem for myself. Unfortunately I did not find any library thats suits my needs to produce a svg visualization of an xml comparison.

Therefore I started an open source library inspired by the X-Diff algorithm. So just for fun and in the hope to find someone supporting the XmlXdiff library. Till now it is not a bullet prove library and still under construction but here is the result for your example snippet:

Code producing this result:

    from XmlXdiff.XReport import DrawXmlDiff

    _xml1 = """<frame xmlns:soapenv="sn" xmlns:mes="meas" xmlns:typ="type">
    <soapenv:Body>
      <mes:GetItem>
        <mes:ItemShape>
          <typ:BaseShape>IdOnly</typ:BaseShape>
          <typ:BodyType>Text</typ:BodyType>
          <typ:AdditionalProperties>
            <typ:FieldURI FieldURI="item:Subject" />
            <typ:FieldURI FieldURI="item:Categories" />
          </typ:AdditionalProperties>
        </mes:ItemShape>
        <mes:ItemIds>
          <typ:ItemId Id="AAMYAAA="/>
        </mes:ItemIds>
      </mes:GetItem>
    </soapenv:Body>
    </frame>"""
    _xml2 = """<frame xmlns:soapenv="sn" xmlns:mes="meas" xmlns:typ="type">
    <soapenv:Body>
      <mes:GetItem>
        <mes:ItemIds>
          <typ:ItemId Id="AAMYAAA="/>
        </mes:ItemIds>
        <mes:ItemShape>
          <typ:BodyType>Text</typ:BodyType>
          <typ:BaseShape>IdOnly</typ:BaseShape>
          <typ:AdditionalProperties>
            <typ:FieldURI FieldURI="item:Categories" />
            <typ:FieldURI FieldURI="item:Subject" />
          </typ:AdditionalProperties>
        </mes:ItemShape>
      </mes:GetItem>
    </soapenv:Body>
    </frame>"""

    _path1 = '{}\\..\\..\\tests\\simple\\xml1.xml'.format(getPath())
    _path2 = '{}\\..\\..\\tests\\simple\\xml2.xml'.format(getPath())
    _out = '{}\\..\\..\\tests\\simple\\xdiff.svg'.format(getPath())

    with open(_path1, "w") as f:
        f.write(_xml1)

    with open(_path2, "w") as f:
        f.write(_xml2)

    x = DrawXmlDiff(_path1, _path2)
    x.draw()
    x.saveSvg(_out)

Answer 6

To summarise, addressing your requirements:

1. Structurally aware, not line-based comparison: Yes
2. Can run on Windows: Yes
3. Orderless Comparison/Move Handling: Yes
4. Side-by-Side comparison output: Yes
5. Ignoring expected changes: Yes
6. Free: No, but a free trial is available.

XML Compare, developed by DeltaXML, is a structurally aware XML Comparison tool that can be run on Windows, as well as Linux and Mac, using Java. XML Compare can be used via command line, REST API, and Java API.

XML Compare's diff outputs are valid XML, meaning that they can be readily processed by other applications, and into other output formats via post-processing configuration. Changes are identified by the addition of new attributes in the diff output that indicate whether the content or structure was present in the A input, present in the B input, and if it is the same in both or has changed. It follows a simple "A!=B" format, see the example snippet below.

<height deltaxml:deltaV2="A!=B">
           <deltaxml:textGroup deltaxml:deltaV2="A!=B">
              <deltaxml:text deltaxml:deltaV2="A">up to 1.4 meters</deltaxml:text>
              <deltaxml:text deltaxml:deltaV2="B">up to 1.3 meters</deltaxml:text>
           </deltaxml:textGroup>
        </height>

Regarding your requirement for accounting for content that has moved, XML Compare is highly configurable. There are dozens of pre-configured input and output processors and filters, and custom pipelines and filters can be created using XSLT.

Specific to your requirements there are pre-configured facilities for Comparing Orderless Elements in the case of comparing where the order of elements is not significant, Detecting and Handling Moves, and Ignoring Changes where they are expected and do not need to be highlighted.

Finally, one of pre-configured output formats available is a side-by-side HTML diff report which is built on the delta output. In cases where you need a more specific output however, you can again configure and process the output using XSLT or the existing configuration options. Below is a screenshot of the side-by-side diff report:

Disclosure: I am an employee of DeltaXML.