Fixed CND parsing under Windows OS

src/PHPCR/Util/CND/Reader/BufferReader.php

@@ -4,28 +4,62 @@
 
 /**
  * @author Daniel Barsotti <daniel.barsotti@liip.ch>
+ * @author Nikola Petkanski <nikola@petkanski.com>
  */
 class BufferReader implements ReaderInterface
 {
+    /**
+     * @var string
+     */
     protected $eofMarker;
 
+    /**
+     * @var string
+     */
+    protected $eolMarker;
+
+    /**
+     * @var string
+     */
     protected $buffer;
 
+    /**
+     * @var int
+     */
     protected $startPos;
 
+    /**
+     * @var int
+     */
     protected $forwardPos;
 
+    /**
+     * @var int
+     */
     protected $curLine;
 
+    /**
+     * @var int
+     */
     protected $curCol;
 
+    /**
+     * @var int
+     */
     protected $nextCurLine;
 
+    /**
+     * @var int
+     */
     protected $nextCurCol;
 
+    /**
+     * @param string $buffer
+     */
     public function __construct($buffer)
     {
         $this->eofMarker = chr(1);
+        $this->eolMarker = PHP_EOL;
         $this->buffer = $buffer . $this->eofMarker;
 
         $this->reset();
@@ -40,11 +74,22 @@ public function reset()
         $this->nextCurLine = $this->nextCurCol = 1;
     }
 
+    /**
+     * @return string
+     */
     public function getEofMarker()
     {
         return $this->eofMarker;
     }
 
+    /**
+     * @return string
+     */
+    public function getEolMarker()
+    {
+        return $this->eolMarker;
+    }
+
     /**
      * @return int
      */
@@ -75,6 +120,9 @@ public function currentChar()
         return substr($this->buffer, $this->forwardPos, 1);
     }
 
+    /**
+     * @return bool
+     */
     public function isEof()
     {
         return $this->currentChar() === $this->getEofMarker()
@@ -83,6 +131,24 @@ public function isEof()
             || $this->forwardPos > strlen($this->buffer);
     }
 
+    /**
+     * @return bool
+     */
+    public function isEol()
+    {
+        $current = $this->current();
+        $eolMarkerLength = strlen($this->getEolMarker());
+
+        // look ahead as far as the length of the EOL marker
+        $lookAhead = substr($this->buffer, $this->startPos, $this->forwardPos - $this->startPos + ($eolMarkerLength - 1));
+        $marker = $this->getEolMarker();
+
+        $result = preg_match('#'. preg_quote($marker) .'$#', $current) === 1;
+        $result = $result || preg_match('#'. preg_quote($marker) .'$#', $lookAhead) === 1;
+
+        return $result;
+    }
+
     /**
      * Advance the forward position and return the literal delimited by start and end position
      * @return string
@@ -94,7 +160,9 @@ public function forward()
             $this->nextCurCol++;
         }
 
-        if ($this->current() === PHP_EOL) {
+        if ($this->isEol()) {
+            $eolMarkerLength = strlen($this->getEolMarker());
+            $this->forwardPos += ($eolMarkerLength - 1); // we already incremented with one
             $this->nextCurLine++;
             $this->nextCurCol = 1;
         }

src/PHPCR/Util/CND/Reader/FileReader.php

@@ -4,24 +4,35 @@
 
 /**
  * @author Daniel Barsotti <daniel.barsotti@liip.ch>
+ * @author Nikola Petkanski <nikola@petkanski.com>
  */
 class FileReader extends BufferReader
 {
-    protected $fileName;
+    /**
+     * @var string
+     */
+    protected $filePath;
 
-    public function __construct($fileName)
+    /**
+     * @param string $path
+     * @throws \InvalidArgumentException
+     */
+    public function __construct($path)
     {
-        if (!file_exists($fileName)) {
-            throw new \InvalidArgumentException(sprintf("Invalid file '%s'", $fileName));
+        if (!file_exists($path)) {
+            throw new \InvalidArgumentException(sprintf("Invalid file '%s'", $path));
         }
 
-        $this->fileName = $fileName;
+        $this->path = $path;
 
-        parent::__construct(file_get_contents($fileName));
+        parent::__construct(file_get_contents($path));
     }
 
-    public function getFileName()
+    /**
+     * @return string
+     */
+    public function getPath()
     {
-        return $this->fileName;
+        return $this->path;
     }
 }

src/PHPCR/Util/CND/Reader/ReaderInterface.php

@@ -8,17 +8,30 @@
 interface ReaderInterface
 {
     /**
-     * @return bool
+     * @return string
      */
     public function getEofMarker();
 
+    /**
+     * @return string
+     */
+    public function getEolMarker();
+
     /**
      * @return string with just one character
      */
     public function currentChar();
 
+    /**
+     * @return bool
+     */
     public function isEof();
 
+    /**
+     * @return bool
+     */
+    public function isEol();
+
     /**
      * @return int
      */

src/PHPCR/Util/CND/Scanner/GenericScanner.php

@@ -12,6 +12,7 @@
  * the token generation to your needs.
  *
  * @author Daniel Barsotti <daniel.barsotti@liip.ch>
+ * @author Nikola Petkanski <nikola@petkanski.com>
  */
 class GenericScanner extends AbstractScanner
 {
@@ -83,21 +84,31 @@ protected function consumeSpaces(ReaderInterface $reader)
      */
     protected function consumeNewLine(ReaderInterface $reader)
     {
-        if ($reader->currentChar() === PHP_EOL) {
+        $current = '';
+        while (strlen($current) < strlen($reader->getEolMarker())) {
+            $current = $reader->forward();
+        }
 
-            $token = new GenericToken(GenericToken::TK_NEWLINE, PHP_EOL);
+        if ($reader->isEol()) {
+            $token = new GenericToken(GenericToken::TK_NEWLINE, $reader->getEolMarker());
             $this->addToken($reader, $token);
 
-
-            while ($reader->forward() === PHP_EOL) {
+            while ($reader->isEol()) {
                 $reader->consume();
-                $reader->forward();
+
+                $current = '';
+                while (strlen($current) < strlen($reader->getEolMarker())) {
+                    $current = $reader->forward();
+                }
             }
+
             $reader->rewind();
 
             return true;
         }
 
+        $reader->rewind();
+
         return false;
     }
 
@@ -116,7 +127,7 @@ protected function consumeString(ReaderInterface $reader)
             $char = $reader->forwardChar();
             while ($char !== $curDelimiter) {
 
-                if ($char === PHP_EOL) {
+                if ($reader->isEol()) {
                     throw new ScannerException($reader, "Newline detected in string");
                 }
 
@@ -226,10 +237,8 @@ protected function consumeLineComments(ReaderInterface $reader)
 
                 if ($reader->current() === $delimiter) {
 
-                    // consume to end of line
-                    $char = $reader->currentChar();
-                    while (!$reader->isEof() && $char !== PHP_EOL) {
-                        $char = $reader->forwardChar();
+                    while (!$reader->isEof() && !$reader->isEol()) {
+                        $reader->forward();
                     }
                     $token = new GenericToken(GenericToken::TK_COMMENT, $reader->consume());
                     $this->addToken($reader, $token);

tests/PHPCR/Tests/Util/CND/Fixtures/files/WindowsTestFile.php

@@ -0,0 +1,18 @@
+<?php
+
+namespace Test\Foobar;
+
+class TestClass
+{
+    /**
+     * Block comment
+     */
+    public function testMethod($testParam)
+    {
+        // Line comment
+        $string = 'This is a "Test // string"';
+        return "Test string";
+    }
+
+    // String in "comment"
+}

tests/PHPCR/Tests/Util/CND/Fixtures/files/WindowsTestFile.txt

@@ -0,0 +1,3 @@
+This is a test file...
+
+...containing dummy content.

tests/PHPCR/Tests/Util/CND/Reader/BufferReaderTest.php

@@ -6,16 +6,38 @@
 
 class BufferReaderTest extends \PHPUnit_Framework_TestCase
 {
-    public function test__construct()
+    public function testWindowsLineEndings()
     {
-        $buffer = "Some random\nstring";
+        $this->doTestReader("\r\n");
+    }
+
+    public function testUnixLineEndings()
+    {
+        $this->doTestReader("\n");
+    }
+
+    /**
+     * @param string $eolMarker
+     */
+    protected function doTestReader($eolMarker)
+    {
+        $buffer = "Some random{$eolMarker}string";
         $reader = new BufferReader($buffer);
 
         $this->assertInstanceOf('\PHPCR\Util\CND\Reader\BufferReader', $reader);
         $this->assertAttributeEquals($buffer . $reader->getEofMarker(), 'buffer', $reader);
         $this->assertAttributeEquals(0, 'startPos', $reader);
         $this->assertAttributeEquals(0, 'forwardPos', $reader);
 
+        // test whether the current EOL marker is correctly set
+        $this->assertAttributeEquals(PHP_EOL, 'eolMarker', $reader);
+
+        // swap the EOL marker with the one for the current platform being tested
+        $reflection = new \ReflectionObject($reader);
+        $property = $reflection->getProperty('eolMarker');
+        $property->setAccessible(true);
+        $property->setValue($reader, $eolMarker);
+
         $this->assertEquals(1, $reader->getCurrentLine());
         $this->assertEquals(1, $reader->getCurrentColumn());
 
@@ -55,8 +77,11 @@ public function test__construct()
 
         $this->assertEquals(12, $reader->getCurrentColumn());
 
-        $this->assertEquals(PHP_EOL, $reader->forward());
-        $this->assertEquals(PHP_EOL, $reader->consume());
+        $this->assertFalse($reader->isEol());
+        $this->assertEquals($eolMarker, $reader->forward());
+        $this->assertTrue($reader->isEol());
+
+        $this->assertEquals($eolMarker, $reader->consume());
 
         $this->assertEquals(2, $reader->getCurrentLine());
         $this->assertEquals(1, $reader->getCurrentColumn());