Skip to content

Commit

Permalink
Add a few xslt files
Browse files Browse the repository at this point in the history
  • Loading branch information
@sodre
sodre committed Nov 20, 2017
1 parent f19061b commit a1643ef
Show file tree
Hide file tree
Showing 5 changed files with 376 additions and 0 deletions.
1 change: 1 addition & 0 deletions Makefile
View file
Original file line number Diff line number Diff line change
Expand Up @@ -56,6 +56,7 @@ NIFI-$(VERSION): nifi-$(NIFI_VERSION) nifi-toolkit-$(NIFI_VERSION) jq-$(JQ_VERSI
mkdir -p $@/lib $@/bin
mv jq-$(JQ_VERSION)-linux64 $@/bin/jq
find $@/bin -type f -exec chmod 755 {} \;
cp -avf xslt $@/lib/nifi-xslt
mv nifi-$(NIFI_VERSION) $@/lib/nifi
mv nifi-toolkit-$(NIFI_VERSION) $@/lib/nifi-toolkit
find $@/lib/nifi-toolkit/bin -type f -exec chmod 755 {} \;
Expand Down
1 change: 1 addition & 0 deletions meta/nifi_env.sh
View file
Original file line number Diff line number Diff line change
@@ -1,5 +1,6 @@
NIFI_DIRNAME=${PARCEL_DIRNAME:-"NIFI-1.4.0"}
export CDH_NIFI_HOME=$PARCELS_ROOT/$NIFI_DIRNAME/lib/nifi
export CDH_NIFI_TOOLKIT_HOME=$PARCELS_ROOT/$NIFI_DIRNAME/lib/nifi-toolkit
export CDH_NIFI_XSLT=$PARCELS_ROOT/$NIFI_DIRNAME/lib/nifi-xslt

alias jq=$PARCELS_ROOT/$NIFI_DIRNAME/bin/jq
20 changes: 20 additions & 0 deletions xslt/hadoop2element-value.xslt
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,20 @@
<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

<xsl:template match="configuration" >
<configuration>
<xsl:apply-templates/>
</configuration>
</xsl:template>
<xsl:template match="property">
<xsl:choose>
<xsl:when test="starts-with(name, 'cdh')"></xsl:when>
<xsl:otherwise>
<xsl:element name = "{name}">
<xsl:value-of select="value"/>
</xsl:element>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
</xsl:stylesheet>
284 changes: 284 additions & 0 deletions xslt/merge.xslt
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,284 @@
<?xml version="1.0"?>

<!--
Merging two XML files
Version 1.6
LGPL (c) Oliver Becker, 2002-07-05
obecker@informatik.hu-berlin.de
-->

<xslt:transform version="1.0"
xmlns:xslt="http://www.w3.org/1999/XSL/Transform"
xmlns:m="http://informatik.hu-berlin.de/merge"
exclude-result-prefixes="m">


<!-- Normalize the contents of text, comment, and processing-instruction
nodes before comparing?
Default: yes -->
<xslt:param name="normalize" select="'yes'" />

<!-- Don't merge elements with this (qualified) name -->
<xslt:param name="dontmerge" />

<!-- If set to true, text nodes in file1 will be replaced -->
<xslt:param name="replace" select="false()" />

<!-- Variant 1: Source document looks like
<?xml version="1.0"?>
<merge xmlns="http://informatik.hu-berlin.de/merge">
<file1>file1.xml</file1>
<file2>file2.xml</file2>
</merge>
The transformation sheet merges file1.xml and file2.xml.
-->
<xslt:template match="m:merge" >
<xslt:variable name="file1" select="string(m:file1)" />
<xslt:variable name="file2" select="string(m:file2)" />
<xslt:message>
<xslt:text />Merging '<xslt:value-of select="$file1" />
<xslt:text />' and '<xslt:value-of select="$file2"/>'<xslt:text />
</xslt:message>
<xslt:if test="$file1='' or $file2=''">
<xslt:message terminate="yes">
<xslt:text>No files to merge specified</xslt:text>
</xslt:message>
</xslt:if>
<xslt:call-template name="m:merge">
<xslt:with-param name="nodes1" select="document($file1,/*)/node()" />
<xslt:with-param name="nodes2" select="document($file2,/*)/node()" />
</xslt:call-template>
</xslt:template>


<!-- Variant 2:
The transformation sheet merges the source document with the
document provided by the parameter "with".
-->
<xslt:param name="with" />

<xslt:template match="*">
<xslt:message>
<xslt:text />Merging input with '<xslt:value-of select="$with"/>
<xslt:text>'</xslt:text>
</xslt:message>
<xslt:if test="string($with)=''">
<xslt:message terminate="yes">
<xslt:text>No input file specified (parameter 'with')</xslt:text>
</xslt:message>
</xslt:if>

<xslt:call-template name="m:merge">
<xslt:with-param name="nodes1" select="/node()" />
<xslt:with-param name="nodes2" select="document($with,/*)/node()" />
</xslt:call-template>
</xslt:template>


<!-- ============================================================== -->

<!-- The "merge" template -->
<xslt:template name="m:merge">
<xslt:param name="nodes1" />
<xslt:param name="nodes2" />

<xslt:choose>
<!-- Is $nodes1 resp. $nodes2 empty? -->
<xslt:when test="count($nodes1)=0">
<xslt:copy-of select="$nodes2" />
</xslt:when>
<xslt:when test="count($nodes2)=0">
<xslt:copy-of select="$nodes1" />
</xslt:when>

<xslt:otherwise>
<!-- Split $nodes1 and $nodes2 -->
<xslt:variable name="first1" select="$nodes1[1]" />
<xslt:variable name="rest1" select="$nodes1[position()!=1]" />
<xslt:variable name="first2" select="$nodes2[1]" />
<xslt:variable name="rest2" select="$nodes2[position()!=1]" />
<!-- Determine type of node $first1 -->
<xslt:variable name="type1">
<xslt:apply-templates mode="m:detect-type" select="$first1" />
</xslt:variable>

<!-- Compare $first1 and $first2 -->
<xslt:variable name="diff-first">
<xslt:call-template name="m:compare-nodes">
<xslt:with-param name="node1" select="$first1" />
<xslt:with-param name="node2" select="$first2" />
</xslt:call-template>
</xslt:variable>

<xslt:choose>
<!-- $first1 != $first2 -->
<xslt:when test="$diff-first='!'">
<!-- Compare $first1 and $rest2 -->
<xslt:variable name="diff-rest">
<xslt:for-each select="$rest2">
<xslt:call-template name="m:compare-nodes">
<xslt:with-param name="node1" select="$first1" />
<xslt:with-param name="node2" select="." />
</xslt:call-template>
</xslt:for-each>
</xslt:variable>

<xslt:choose>
<!-- $first1 is in $rest2 and
$first1 is *not* an empty text node -->
<xslt:when test="contains($diff-rest,'=') and
not($type1='text' and
normalize-space($first1)='')">
<!-- determine position of $first1 in $nodes2
and copy all preceding nodes of $nodes2 -->
<xslt:variable name="pos"
select="string-length(substring-before(
$diff-rest,'=')) + 2" />
<xslt:copy-of
select="$nodes2[position() &lt; $pos]" />
<!-- merge $first1 with its equivalent node -->
<xslt:choose>
<!-- Elements: merge -->
<xslt:when test="$type1='element'">
<xslt:element name="{name($first1)}"
namespace="{namespace-uri($first1)}">
<xslt:copy-of select="$first1/namespace::*" />
<xslt:copy-of select="$first2/namespace::*" />
<xslt:copy-of select="$first1/@*" />
<xslt:call-template name="m:merge">
<xslt:with-param name="nodes1"
select="$first1/node()" />
<xslt:with-param name="nodes2"
select="$nodes2[position()=$pos]/node()" />
</xslt:call-template>
</xslt:element>
</xslt:when>
<!-- Other: copy -->
<xslt:otherwise>
<xslt:copy-of select="$first1" />
</xslt:otherwise>
</xslt:choose>

<!-- Merge $rest1 and rest of $nodes2 -->
<xslt:call-template name="m:merge">
<xslt:with-param name="nodes1" select="$rest1" />
<xslt:with-param name="nodes2"
select="$nodes2[position() &gt; $pos]" />
</xslt:call-template>
</xslt:when>

<!-- $first1 is a text node and replace mode was
activated -->
<xslt:when test="$type1='text' and $replace">
<xslt:call-template name="m:merge">
<xslt:with-param name="nodes1" select="$rest1" />
<xslt:with-param name="nodes2" select="$nodes2" />
</xslt:call-template>
</xslt:when>

<!-- else: $first1 is not in $rest2 or
$first1 is an empty text node -->
<xslt:otherwise>
<xslt:copy-of select="$first1" />
<xslt:call-template name="m:merge">
<xslt:with-param name="nodes1" select="$rest1" />
<xslt:with-param name="nodes2" select="$nodes2" />
</xslt:call-template>
</xslt:otherwise>
</xslt:choose>
</xslt:when>

<!-- else: $first1 = $first2 -->
<xslt:otherwise>
<xslt:choose>
<!-- Elements: merge -->
<xslt:when test="$type1='element'">
<xslt:element name="{name($first1)}"
namespace="{namespace-uri($first1)}">
<xslt:copy-of select="$first1/namespace::*" />
<xslt:copy-of select="$first2/namespace::*" />
<xslt:copy-of select="$first1/@*" />
<xslt:call-template name="m:merge">
<xslt:with-param name="nodes1"
select="$first1/node()" />
<xslt:with-param name="nodes2"
select="$first2/node()" />
</xslt:call-template>
</xslt:element>
</xslt:when>
<!-- Other: copy -->
<xslt:otherwise>
<xslt:copy-of select="$first1" />
</xslt:otherwise>
</xslt:choose>

<!-- Merge $rest1 and $rest2 -->
<xslt:call-template name="m:merge">
<xslt:with-param name="nodes1" select="$rest1" />
<xslt:with-param name="nodes2" select="$rest2" />
</xslt:call-template>
</xslt:otherwise>
</xslt:choose>
</xslt:otherwise>
</xslt:choose>
</xslt:template>


<!-- Comparing single nodes:
if $node1 and $node2 are equivalent then the template creates a
text node "=" otherwise a text node "!" -->
<xslt:template name="m:compare-nodes">
<xslt:param name="node1" />
<xslt:param name="node2" />
<xslt:variable name="type1">
<xslt:apply-templates mode="m:detect-type" select="$node1" />
</xslt:variable>
<xslt:variable name="type2">
<xslt:apply-templates mode="m:detect-type" select="$node2" />
</xslt:variable>

<xslt:choose>
<!-- Are $node1 and $node2 element nodes with the same name? -->
<xslt:when test="$type1='element' and $type2='element' and
local-name($node1)=local-name($node2) and
namespace-uri($node1)=namespace-uri($node2) and
name($node1)!=$dontmerge and name($node2)!=$dontmerge">
<!-- Comparing the attributes -->
<xslt:variable name="diff-att">
<!-- same number ... -->
<xslt:if test="count($node1/@*)!=count($node2/@*)">.</xslt:if>
<!-- ... and same name/content -->
<xslt:for-each select="$node1/@*">
<xslt:if test="not($node2/@*
[local-name()=local-name(current()) and
namespace-uri()=namespace-uri(current()) and
.=current()])">.</xslt:if>
</xslt:for-each>
</xslt:variable>
<xslt:choose>
<xslt:when test="string-length($diff-att)!=0">!</xslt:when>
<xslt:otherwise>=</xslt:otherwise>
</xslt:choose>
</xslt:when>

<!-- Other nodes: test for the same type and content -->
<xslt:when test="$type1!='element' and $type1=$type2 and
name($node1)=name($node2) and
($node1=$node2 or
($normalize='yes' and
normalize-space($node1)=
normalize-space($node2)))">=</xslt:when>

<!-- Otherwise: different node types or different name/content -->
<xslt:otherwise>!</xslt:otherwise>
</xslt:choose>
</xslt:template>


<!-- Type detection, thanks to M. H. Kay -->
<xslt:template match="*" mode="m:detect-type">element</xslt:template>
<xslt:template match="text()" mode="m:detect-type">text</xslt:template>
<xslt:template match="comment()" mode="m:detect-type">comment</xslt:template>
<xslt:template match="processing-instruction()" mode="m:detect-type">pi</xslt:template>

</xslt:transform>
70 changes: 70 additions & 0 deletions xslt/xml2json.xslt
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,70 @@
<?xml version="1.0" encoding="UTF-8" ?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output method="text" encoding="utf-8"/>

<xsl:template match="/node()">
<xsl:text>{</xsl:text>
<xsl:apply-templates select="." mode="detect" />
<xsl:text>}</xsl:text>
</xsl:template>

<xsl:template match="*" mode="detect">
<xsl:choose>
<xsl:when test="name(preceding-sibling::*[1]) = name(current()) and name(following-sibling::*[1]) != name(current())">
<xsl:apply-templates select="." mode="obj-content" />
<xsl:text>]</xsl:text>
<xsl:if test="count(following-sibling::*[name() != name(current())]) &gt; 0">, </xsl:if>
</xsl:when>
<xsl:when test="name(preceding-sibling::*[1]) = name(current())">
<xsl:apply-templates select="." mode="obj-content" />
<xsl:if test="name(following-sibling::*) = name(current())">, </xsl:if>
</xsl:when>
<xsl:when test="following-sibling::*[1][name() = name(current())]">
<xsl:text>"</xsl:text><xsl:value-of select="name()"/><xsl:text>" : [</xsl:text>
<xsl:apply-templates select="." mode="obj-content" /><xsl:text>, </xsl:text>
</xsl:when>
<xsl:when test="count(./child::*) > 0 or count(@*) > 0">
<xsl:text>"</xsl:text><xsl:value-of select="name()"/>" : <xsl:apply-templates select="." mode="obj-content" />
<xsl:if test="count(following-sibling::*) &gt; 0">, </xsl:if>
</xsl:when>
<xsl:when test="count(./child::*) = 0">
<xsl:text>"</xsl:text><xsl:value-of select="name()"/>" : "<xsl:apply-templates select="."/><xsl:text>"</xsl:text>
<xsl:if test="count(following-sibling::*) &gt; 0">, </xsl:if>
</xsl:when>
</xsl:choose>
</xsl:template>

<xsl:template match="*" mode="obj-content">
<xsl:text>{</xsl:text>
<xsl:apply-templates select="@*" mode="attr" />
<xsl:if test="count(@*) &gt; 0 and (count(child::*) &gt; 0 or text())">, </xsl:if>
<xsl:apply-templates select="./*" mode="detect" />
<xsl:if test="count(child::*) = 0 and text() and not(@*)">
<xsl:text>"</xsl:text><xsl:value-of select="name()"/>" : "<xsl:value-of select="text()"/><xsl:text>"</xsl:text>
</xsl:if>
<xsl:if test="count(child::*) = 0 and text() and @*">
<xsl:text>"text" : "</xsl:text><xsl:value-of select="text()"/><xsl:text>"</xsl:text>
</xsl:if>
<xsl:text>}</xsl:text>
<xsl:if test="position() &lt; last()">, </xsl:if>
</xsl:template>

<xsl:template match="@*" mode="attr">
<xsl:text>"</xsl:text><xsl:value-of select="name()"/>" : "<xsl:value-of select="."/><xsl:text>"</xsl:text>
<xsl:if test="position() &lt; last()">,</xsl:if>
</xsl:template>

<xsl:template match="node/@TEXT | text()" name="removeBreaks">
<xsl:param name="pText" select="normalize-space(.)"/>
<xsl:choose>
<xsl:when test="not(contains($pText, '&#xA;'))"><xsl:copy-of select="$pText"/></xsl:when>
<xsl:otherwise>
<xsl:value-of select="concat(substring-before($pText, '&#xD;&#xA;'), ' ')"/>
<xsl:call-template name="removeBreaks">
<xsl:with-param name="pText" select="substring-after($pText, '&#xD;&#xA;')"/>
</xsl:call-template>
</xsl:otherwise>
</xsl:choose>
</xsl:template>

</xsl:stylesheet>

0 comments on commit a1643ef

Please sign in to comment.