Xliff12::getCurrentSegment() - Code Metrics - Inspection of "Fixed help-id in xliff 1.2" - matecat/xliff-parser - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 149a8e...a14c95 )

by Domenico

created 2024-08-29 15:09 UTC

Xliff12::getCurrentSegment() A

↳ Parent: Xliff12

Complexity

Conditions	3
Paths	2

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	3
eloc	3
c	1
b	0
f	0
nc	2
nop	0
dl	0
loc	6
rs	10

<?php
/**
 * Created by PhpStorm.
 * @author hashashiyyin [email protected] / [email protected]
 * Date: 02/08/24
 * Time: 11:45
 *
 */

namespace Matecat\XliffParser\XliffReplacer;

use Matecat\XliffParser\Utils\Strings;

class Xliff12 extends AbstractXliffReplacer {

    /**
     * @var array
     */
    protected array $nodesToBuffer = [
            'source',
            'seg-source',
            'note',
            'context-group'
    ];

    /**
     * @var string
     */
    protected string $tuTagName = 'trans-unit';

    /**
     * @var string
     */
    protected string $alternativeMatchesTag = 'alt-trans';

    /**
     * @var string
     */
    protected string $namespace = "mtc";       // Custom namespace

    /**
     * @inheritDoc
     */
    protected function tagOpen( $parser, string $name, array $attr ) {

        $this->handleOpenUnit( $name, $attr );

        $this->trySetAltTrans( $name );;
        $this->checkSetInTarget( $name );

        // open buffer
        $this->setInBuffer( $name );

        // check if we are inside a <target>, obviously this happen only if there are targets inside the trans-unit
        // <target> must be stripped to be replaced, so this check avoids <target> reconstruction
        if ( !$this->inTarget ) {

            $tag = '';

            // construct tag
            $tag .= "<$name ";

            foreach ( $attr as $k => $v ) {

                //if tag name is file, we must replace the target-language attribute
                if ( $name === 'file' && $k === 'target-language' && !empty( $this->targetLang ) ) {
                    //replace Target language with job language provided from constructor
                    $tag .= "$k=\"$this->targetLang\" ";
                } else {
                    $tag .= "$k=\"$v\" ";
                }

            }

            $seg = $this->getCurrentSegment();

            if ( $name === $this->tuTagName && !empty( $seg ) && isset( $seg[ 'sid' ] ) ) {

                // add `help-id` to xliff v.1*
                if ( strpos( $tag, 'help-id' ) === false ) {
                    if ( !empty( $seg[ 'sid' ] ) ) {
                        $tag .= "help-id=\"{$seg[ 'sid' ]}\" ";
                    }
                }

            }

            $tag = $this->handleOpenXliffTag( $name, $attr, $tag );

            $this->checkForSelfClosedTagAndFlush( $parser, $tag );

        }

    }


    /**
     * @inheritDoc
     */
    protected function tagClose( $parser, string $name ) {
        $tag = '';

        /**
         * if is a tag within <target> or
         * if it is an empty tag, do not add closing tag because we have already closed it in
         *
         * self::tagOpen method
         */
        if ( !$this->isEmpty ) {

            if ( !$this->inTarget ) {
                $tag = "</$name>";
            }

            if ( 'target' == $name && !$this->inAltTrans ) {

                if ( isset( $this->transUnits[ $this->currentTransUnitId ] ) ) {

                    // get translation of current segment, by indirect indexing: id -> positional index -> segment
                    // actually there may be more than one segment to that ID if there are two mrk of the same source segment
                    $tag = $this->rebuildTarget();

                }

                $this->targetWasWritten = true;
                // signal we are leaving a target
                $this->inTarget = false;
                $this->postProcAndFlush( $this->outputFP, $tag, true );

            } elseif ( in_array( $name, $this->nodesToBuffer ) ) { // we are closing a critical CDATA section

                $this->bufferIsActive = false;
                $tag                  = $this->CDATABuffer . "</$name>";
                $this->CDATABuffer    = "";

                //flush to the pointer
                $this->postProcAndFlush( $this->outputFP, $tag );

            } elseif ( $name === $this->tuTagName ) {

                $tag = "";

                // handling </trans-unit> closure
                if ( !$this->targetWasWritten ) {

                    if ( isset( $this->transUnits[ $this->currentTransUnitId ] ) ) {
                        $tag = $this->rebuildTarget();
                    } else {
                        $tag = $this->createTargetTag( "", "" );
                    }

                }

                $tag                    .= "</$this->tuTagName>";
                $this->targetWasWritten = false;
                $this->postProcAndFlush( $this->outputFP, $tag );

            } elseif ( $this->bufferIsActive ) { // this is a tag ( <g | <mrk ) inside a seg or seg-source tag
                $this->CDATABuffer .= "</$name>";
                // Do NOT Flush
            } else { //generic tag closure do Nothing
                // flush to pointer
                $this->postProcAndFlush( $this->outputFP, $tag );
            }

        } elseif ( in_array( $name, $this->nodesToBuffer ) ) {

            $this->isEmpty        = false;
            $this->bufferIsActive = false;
            $tag                  = $this->CDATABuffer;
            $this->CDATABuffer    = "";

            //flush to the pointer
            $this->postProcAndFlush( $this->outputFP, $tag );

        } else {
            //ok, nothing to be done; reset flag for next coming tag
            $this->isEmpty = false;
        }

        // try to signal that we are leaving a target
        $this->tryUnsetAltTrans( $name );

        // check if we are leaving a <trans-unit> (xliff v1.*) or <unit> (xliff v2.*)
        if ( $this->tuTagName === $name ) {
            $this->currentTransUnitIsTranslatable = null;
            $this->inTU                           = false;
            $this->hasWrittenCounts               = false;

            $this->resetCounts();
        }
    }

    /**
     * prepare segment tagging for xliff insertion
     *
     * @param array  $seg
     * @param string $transUnitTranslation
     *
     * @return string
     */
    protected function prepareTranslation( array $seg, string $transUnitTranslation = "" ): string {

        $segment     = Strings::removeDangerousChars( $seg [ 'segment' ] );
        $translation = Strings::removeDangerousChars( $seg [ 'translation' ] );

        if ( $seg [ 'translation' ] == '' ) {
            $translation = $segment;
        } else {
            if ( $this->callback instanceof XliffReplacerCallbackInterface ) {
                $error = ( !empty( $seg[ 'error' ] ) ) ? $seg[ 'error' ] : null;
                if ( $this->callback->thereAreErrors( $seg[ 'sid' ], $segment, $translation, [], $error ) ) {
                    $translation = '|||UNTRANSLATED_CONTENT_START|||' . $segment . '|||UNTRANSLATED_CONTENT_END|||';
                }
            }
        }

        $transUnitTranslation .= $seg[ 'prev_tags' ] . $this->rebuildMarks( $seg, $translation ) . ltrim( $seg[ 'succ_tags' ] );

        return $transUnitTranslation;
    }

    protected function rebuildMarks( array $seg, string $translation ): string {

        if ( $seg[ 'mrk_id' ] !== null && $seg[ 'mrk_id' ] != '' ) {
            $translation = "<mrk mid=\"" . $seg[ 'mrk_id' ] . "\" mtype=\"seg\">" . $seg[ 'mrk_prev_tags' ] . $translation . $seg[ 'mrk_succ_tags' ] . "</mrk>";
        }

        return $translation;

    }

    /**
     * This function creates a <target>
     *
     * @param string $translation
     * @param string $stateProp
     *
     * @return string
     */
    private function createTargetTag( string $translation, string $stateProp ): string {
        $targetLang = ' xml:lang="' . $this->targetLang . '"';
        $tag        = "<target $targetLang $stateProp>$translation</target>";
        $tag        .= "\n<count-group name=\"$this->currentTransUnitId\"><count count-type=\"x-matecat-raw\">" . $this->counts[ 'raw_word_count' ] . "</count><count count-type=\"x-matecat-weighted\">" . $this->counts[ 'eq_word_count' ] . '</count></count-group>';

        return $tag;

    }

    protected function rebuildTarget(): string {

        // init translation and state
        $translation  = '';
        $lastMrkState = null;
        $stateProp    = '';

        // we must reset the lastMrkId found because this is a new segment.
        $lastMrkId = -1;

        foreach ( $this->lastTransUnit as $pos => $seg ) {

            /*
             * This routine works to respect the positional orders of markers.
             * In every cycle we check if the mrk of the segment is below or equal the last one.
             * When this is true, means that the mrk id belongs to the next segment with the same internal_id
             * so we MUST stop to apply markers and translations
             * and stop to add eq_word_count
             *
             * Begin:
             * pre-assign zero to the new mrk if this is the first one ( in this segment )
             * If it is null leave it NULL
             */
            if ( (int)$seg[ "mrk_id" ] < 0 && $seg[ "mrk_id" ] !== null ) {
                $seg[ "mrk_id" ] = 0;
            }

            /*
             * WARNING:
             * For those seg-source that doesn't have a mrk ( having a mrk id === null )
             * ( null <= -1 ) === true
             * so, cast to int
             */
            if ( (int)$seg[ "mrk_id" ] <= $lastMrkId ) {
                break;
            }

            // update counts
            if ( !empty( $seg ) ) {
                $this->updateSegmentCounts( $seg );
            }

            // delete translations so the prepareSegment
            // will put source content in target tag
            if ( $this->sourceInTarget ) {
                $seg[ 'translation' ] = '';
                $this->resetCounts();
            }

            // append $translation
            $translation = $this->prepareTranslation( $seg, $translation );

            $lastMrkId = $seg[ "mrk_id" ];

            [ $stateProp, $lastMrkState ] = StatusToStateAttribute::getState( $this->xliffVersion, $seg[ 'status' ], $lastMrkState );

        }

        //append translation
        return $this->createTargetTag( $translation, $stateProp );

    }

    protected function getCurrentSegment(): array {
        if ( $this->currentTransUnitIsTranslatable !== 'no' && isset( $this->transUnits[ $this->currentTransUnitId ] ) ) {
            return $this->segments[ $this->transUnits[ $this->currentTransUnitId ][ 0 ] ]; // TODO try to understand why here is needed to override the method and set 0 index hardcoded
        }

        return [];
    }

}

1			<?php
2			/**
3			* Created by PhpStorm.
4			* @author hashashiyyin [email protected] / [email protected]
5			* Date: 02/08/24
6			* Time: 11:45
7			*
8			*/
9
10			namespace Matecat\XliffParser\XliffReplacer;
11
12			use Matecat\XliffParser\Utils\Strings;
13
14			class Xliff12 extends AbstractXliffReplacer {
15
16			/**
17			* @var array
18			*/
19			protected array $nodesToBuffer = [
20			'source',
21			'seg-source',
22			'note',
23			'context-group'
24			];
25
26			/**
27			* @var string
28			*/
29			protected string $tuTagName = 'trans-unit';
30
31			/**
32			* @var string
33			*/
34			protected string $alternativeMatchesTag = 'alt-trans';
35
36			/**
37			* @var string
38			*/
39			protected string $namespace = "mtc"; // Custom namespace
40
41			/**
42			* @inheritDoc
43			*/
44			protected function tagOpen( $parser, string $name, array $attr ) {
45
46			$this->handleOpenUnit( $name, $attr );
47
48			$this->trySetAltTrans( $name );;
49			$this->checkSetInTarget( $name );
50
51			// open buffer
52			$this->setInBuffer( $name );
53
54			// check if we are inside a <target>, obviously this happen only if there are targets inside the trans-unit
55			// <target> must be stripped to be replaced, so this check avoids <target> reconstruction
56			if ( !$this->inTarget ) {
57
58			$tag = '';
59
60			// construct tag
61			$tag .= "<$name ";
62
63			foreach ( $attr as $k => $v ) {
64
65			//if tag name is file, we must replace the target-language attribute
66			if ( $name === 'file' && $k === 'target-language' && !empty( $this->targetLang ) ) {
67			//replace Target language with job language provided from constructor
68			$tag .= "$k=\"$this->targetLang\" ";
69			} else {
70			$tag .= "$k=\"$v\" ";
71			}
72
73			}
74
75			$seg = $this->getCurrentSegment();
76
77			if ( $name === $this->tuTagName && !empty( $seg ) && isset( $seg[ 'sid' ] ) ) {
78
79			// add `help-id` to xliff v.1*
80			if ( strpos( $tag, 'help-id' ) === false ) {
81			if ( !empty( $seg[ 'sid' ] ) ) {
82			$tag .= "help-id=\"{$seg[ 'sid' ]}\" ";
83			}
84			}
85
86			}
87
88			$tag = $this->handleOpenXliffTag( $name, $attr, $tag );
89
90			$this->checkForSelfClosedTagAndFlush( $parser, $tag );
91
92			}
93
94			}
95
96
97			/**
98			* @inheritDoc
99			*/
100			protected function tagClose( $parser, string $name ) {
101			$tag = '';
102
103			/**
104			* if is a tag within <target> or
105			* if it is an empty tag, do not add closing tag because we have already closed it in
106			*
107			* self::tagOpen method
108			*/
109			if ( !$this->isEmpty ) {
110
111			if ( !$this->inTarget ) {
112			$tag = "</$name>";
113			}
114
115			if ( 'target' == $name && !$this->inAltTrans ) {
116
117			if ( isset( $this->transUnits[ $this->currentTransUnitId ] ) ) {
118
119			// get translation of current segment, by indirect indexing: id -> positional index -> segment
120			// actually there may be more than one segment to that ID if there are two mrk of the same source segment
121			$tag = $this->rebuildTarget();
122
123			}
124
125			$this->targetWasWritten = true;
126			// signal we are leaving a target
127			$this->inTarget = false;
128			$this->postProcAndFlush( $this->outputFP, $tag, true );
129
130			} elseif ( in_array( $name, $this->nodesToBuffer ) ) { // we are closing a critical CDATA section
131
132			$this->bufferIsActive = false;
133			$tag = $this->CDATABuffer . "</$name>";
134			$this->CDATABuffer = "";
135
136			//flush to the pointer
137			$this->postProcAndFlush( $this->outputFP, $tag );
138
139			} elseif ( $name === $this->tuTagName ) {
140
141			$tag = "";
142
143			// handling </trans-unit> closure
144			if ( !$this->targetWasWritten ) {
145
146			if ( isset( $this->transUnits[ $this->currentTransUnitId ] ) ) {
147			$tag = $this->rebuildTarget();
148			} else {
149			$tag = $this->createTargetTag( "", "" );
150			}
151
152			}
153
154			$tag .= "</$this->tuTagName>";
155			$this->targetWasWritten = false;
156			$this->postProcAndFlush( $this->outputFP, $tag );
157
158			} elseif ( $this->bufferIsActive ) { // this is a tag ( <g \| <mrk ) inside a seg or seg-source tag
159			$this->CDATABuffer .= "</$name>";
160			// Do NOT Flush
161			} else { //generic tag closure do Nothing
162			// flush to pointer
163			$this->postProcAndFlush( $this->outputFP, $tag );
164			}
165
166			} elseif ( in_array( $name, $this->nodesToBuffer ) ) {
167
168			$this->isEmpty = false;
169			$this->bufferIsActive = false;
170			$tag = $this->CDATABuffer;
171			$this->CDATABuffer = "";
172
173			//flush to the pointer
174			$this->postProcAndFlush( $this->outputFP, $tag );
175
176			} else {
177			//ok, nothing to be done; reset flag for next coming tag
178			$this->isEmpty = false;
179			}
180
181			// try to signal that we are leaving a target
182			$this->tryUnsetAltTrans( $name );
183
184			// check if we are leaving a <trans-unit> (xliff v1.) or <unit> (xliff v2.)
185			if ( $this->tuTagName === $name ) {
186			$this->currentTransUnitIsTranslatable = null;
187			$this->inTU = false;
188			$this->hasWrittenCounts = false;
189
190			$this->resetCounts();
191			}
192			}
193
194			/**
195			* prepare segment tagging for xliff insertion
196			*
197			* @param array $seg
198			* @param string $transUnitTranslation
199			*
200			* @return string
201			*/
202			protected function prepareTranslation( array $seg, string $transUnitTranslation = "" ): string {
203
204			$segment = Strings::removeDangerousChars( $seg [ 'segment' ] );
205			$translation = Strings::removeDangerousChars( $seg [ 'translation' ] );
206
207			if ( $seg [ 'translation' ] == '' ) {
208			$translation = $segment;
209			} else {
210			if ( $this->callback instanceof XliffReplacerCallbackInterface ) {
211			$error = ( !empty( $seg[ 'error' ] ) ) ? $seg[ 'error' ] : null;
212			if ( $this->callback->thereAreErrors( $seg[ 'sid' ], $segment, $translation, [], $error ) ) {
213			$translation = '\|\|\|UNTRANSLATED_CONTENT_START\|\|\|' . $segment . '\|\|\|UNTRANSLATED_CONTENT_END\|\|\|';
214			}
215			}
216			}
217
218			$transUnitTranslation .= $seg[ 'prev_tags' ] . $this->rebuildMarks( $seg, $translation ) . ltrim( $seg[ 'succ_tags' ] );
219
220			return $transUnitTranslation;
221			}
222
223			protected function rebuildMarks( array $seg, string $translation ): string {
224
225			if ( $seg[ 'mrk_id' ] !== null && $seg[ 'mrk_id' ] != '' ) {
226			$translation = "<mrk mid=\"" . $seg[ 'mrk_id' ] . "\" mtype=\"seg\">" . $seg[ 'mrk_prev_tags' ] . $translation . $seg[ 'mrk_succ_tags' ] . "</mrk>";
227			}
228
229			return $translation;
230
231			}
232
233			/**
234			* This function creates a <target>
235			*
236			* @param string $translation
237			* @param string $stateProp
238			*
239			* @return string
240			*/
241			private function createTargetTag( string $translation, string $stateProp ): string {
242			$targetLang = ' xml:lang="' . $this->targetLang . '"';
243			$tag = "<target $targetLang $stateProp>$translation</target>";
244			$tag .= "\n<count-group name=\"$this->currentTransUnitId\"><count count-type=\"x-matecat-raw\">" . $this->counts[ 'raw_word_count' ] . "</count><count count-type=\"x-matecat-weighted\">" . $this->counts[ 'eq_word_count' ] . '</count></count-group>';
245
246			return $tag;
247
248			}
249
250			protected function rebuildTarget(): string {
251
252			// init translation and state
253			$translation = '';
254			$lastMrkState = null;
255			$stateProp = '';
256
257			// we must reset the lastMrkId found because this is a new segment.
258			$lastMrkId = -1;
259
260			foreach ( $this->lastTransUnit as $pos => $seg ) {
261
262			/*
263			* This routine works to respect the positional orders of markers.
264			* In every cycle we check if the mrk of the segment is below or equal the last one.
265			* When this is true, means that the mrk id belongs to the next segment with the same internal_id
266			* so we MUST stop to apply markers and translations
267			* and stop to add eq_word_count
268			*
269			* Begin:
270			* pre-assign zero to the new mrk if this is the first one ( in this segment )
271			* If it is null leave it NULL
272			*/
273			if ( (int)$seg[ "mrk_id" ] < 0 && $seg[ "mrk_id" ] !== null ) {
274			$seg[ "mrk_id" ] = 0;
275			}
276
277			/*
278			* WARNING:
279			* For those seg-source that doesn't have a mrk ( having a mrk id === null )
280			* ( null <= -1 ) === true
281			* so, cast to int
282			*/
283			if ( (int)$seg[ "mrk_id" ] <= $lastMrkId ) {
284			break;
285			}
286
287			// update counts
288			if ( !empty( $seg ) ) {
289			$this->updateSegmentCounts( $seg );
290			}
291
292			// delete translations so the prepareSegment
293			// will put source content in target tag
294			if ( $this->sourceInTarget ) {
295			$seg[ 'translation' ] = '';
296			$this->resetCounts();
297			}
298
299			// append $translation
300			$translation = $this->prepareTranslation( $seg, $translation );
301
302			$lastMrkId = $seg[ "mrk_id" ];
303
304			[ $stateProp, $lastMrkState ] = StatusToStateAttribute::getState( $this->xliffVersion, $seg[ 'status' ], $lastMrkState );
305
306			}
307
308			//append translation
309			return $this->createTargetTag( $translation, $stateProp );
310
311			}
312
313			protected function getCurrentSegment(): array {
314			if ( $this->currentTransUnitIsTranslatable !== 'no' && isset( $this->transUnits[ $this->currentTransUnitId ] ) ) {
315			return $this->segments[ $this->transUnits[ $this->currentTransUnitId ][ 0 ] ]; // TODO try to understand why here is needed to override the method and set 0 index hardcoded
316			}
317
318			return [];
319			}
320
321			}

matecat / xliff-parser

Push — master ( 149a8e...a14c95 )

Xliff12::getCurrentSegment() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like