Tiny Tiny RSS: Community

Would like to contribute changes to tt-rss

Gog/Forum username: stymiee

I would like to start contributing by cleaning up older code and bringing the codebase closer to PSR-12 and project standards (tab indents, etc), modernize code (change var to public,etc), remove incorrect code (ie return statements in constructors), and make code more readable.

Basic example:

lib/gettext/streams.php
<?php

  // Simple class to wrap file streams, string streams, etc.
  // seek is essential, and it should be byte stream
class StreamReader {
  // should return a string [FIXME: perhaps return array of bytes?]
  function read($bytes) {
    return false;
  }

  // should return new position
  function seekto($position) {
    return false;
  }

  // returns current position
  function currentpos() {
    return false;
  }

  // returns length of entire stream (limit for seekto()s)
  function length() {
    return false;
  }
};

class StringReader {
  var $_pos;
  var $_str;

  function __construct($str='') {
    $this->_str = $str;
    $this->_pos = 0;
  }

  function read($bytes) {
    $data = substr($this->_str, $this->_pos, $bytes);
    $this->_pos += $bytes;
    if (strlen($this->_str)<$this->_pos)
      $this->_pos = strlen($this->_str);

    return $data;
  }

  function seekto($pos) {
    $this->_pos = $pos;
    if (strlen($this->_str)<$this->_pos)
      $this->_pos = strlen($this->_str);
    return $this->_pos;
  }

  function currentpos() {
    return $this->_pos;
  }

  function length() {
    return strlen($this->_str);
  }

};


class FileReader {
  var $_pos;
  var $_fd;
  var $_length;

  function __construct($filename) {
    if (file_exists($filename)) {

      $this->_length=filesize($filename);
      $this->_pos = 0;
      $this->_fd = fopen($filename,'rb');
      if (!$this->_fd) {
        $this->error = 3; // Cannot read file, probably permissions
        return false;
      }
    } else {
      $this->error = 2; // File doesn't exist
      return false;
    }
  }

  function read($bytes) {
    if ($bytes) {
      fseek($this->_fd, $this->_pos);

      // PHP 5.1.1 does not read more than 8192 bytes in one fread()
      // the discussions at PHP Bugs suggest it's the intended behaviour
      $data = '';
      while ($bytes > 0) {
        $chunk  = fread($this->_fd, $bytes);
        $data  .= $chunk;
        $bytes -= strlen($chunk);
      }
      $this->_pos = ftell($this->_fd);

      return $data;
    } else return '';
  }

  function seekto($pos) {
    fseek($this->_fd, $pos);
    $this->_pos = ftell($this->_fd);
    return $this->_pos;
  }

  function currentpos() {
    return $this->_pos;
  }

  function length() {
    return $this->_length;
  }

  function close() {
    fclose($this->_fd);
  }

};

// Preloads entire file in memory first, then creates a StringReader
// over it (it assumes knowledge of StringReader internals)
class CachedFileReader extends StringReader {
  function __construct($filename) {
    if (file_exists($filename)) {

      $length=filesize($filename);
      $fd = fopen($filename,'rb');

      if (!$fd) {
        $this->error = 3; // Cannot read file, probably permissions
        return false;
      }
      $this->_str = fread($fd, $length);
      fclose($fd);

    } else {
      $this->error = 2; // File doesn't exist
      return false;
    }
  }
};


?>

Becomes:

<?php

abstract class Reader
{
	const CANNOT_READ_FILE = 3;
	const FILE_DOES_NOT_EXIST = 2;

	public $error;

	abstract public function read($bytes);
	abstract public function seekto($position);
	abstract public function currentpos();
	abstract public function length();
}

// Simple class to wrap file streams, string streams, etc.
// seek is essential, and it should be byte stream
class StreamReader extends Reader
{
	// should return a string [FIXME: perhaps return array of bytes?]
	public function read($bytes)
	{
		return false;
	}

	// should return new position
	public function seekto($position)
	{
		return false;
	}

	// returns current position
	public function currentpos()
	{
		return false;
	}

	// returns length of entire stream (limit for seekto()s)
	public function length()
	{
		return false;
	}
}

class StringReader extends Reader
{
	public $_pos;
	public $_str;

	public function __construct($str = '') {
		$this->_str = $str;
		$this->_pos = 0;
	}

	public function read($bytes) {
		$data = substr($this->_str, $this->_pos, $bytes);
		$this->_pos += $bytes;
		if (strlen($this->_str)<$this->_pos) {
			$this->_pos = strlen($this->_str);
		}

		return $data;
	}

	public function seekto($pos) {
		$this->_pos = $pos;
		if (strlen($this->_str) < $this->_pos) {
			$this->_pos = strlen($this->_str);
		}
		return $this->_pos;
	}

	public function currentpos() {
		return $this->_pos;
	}

	public function length() {
		return strlen($this->_str);
	}
}


class FileReader extends Reader
{
	public $_pos;
	public $_fd;
	public $_length;

	public function __construct($filename)
	{
		if (file_exists($filename)) {
			$this->_length=filesize($filename);
			$this->_pos = 0;
			$this->_fd = fopen($filename,'rb');
			if (!$this->_fd) {
				$this->error = self::CANNOT_READ_FILE; // Probably permissions
			}
		} else {
			$this->error = self::FILE_DOES_NOT_EXIST;
		}
	}

	public function read($bytes)
	{
		if ($bytes) {
			fseek($this->_fd, $this->_pos);

			// PHP 5.1.1 does not read more than 8192 bytes in one fread()
			// the discussions at PHP Bugs suggest it's the intended behaviour
			$data = '';
			while ($bytes > 0) {
				$chunk  = fread($this->_fd, $bytes);
				$data  .= $chunk;
				$bytes -= strlen($chunk);
			}
			$this->_pos = ftell($this->_fd);

			return $data;
		}

		return '';
	}

	public function seekto($pos)
	{
		fseek($this->_fd, $pos);
		$this->_pos = ftell($this->_fd);
		return $this->_pos;
	}

	public function currentpos()
	{
		return $this->_pos;
	}

	function length()
	{
		return $this->_length;
	}

	function close()
	{
		fclose($this->_fd);
	}
}

// Preloads entire file in memory first, then creates a StringReader
// over it (it assumes knowledge of StringReader internals)
class CachedFileReader extends StringReader
{
	public function __construct($filename)
	{
		parent::__construct();

		if (file_exists($filename)) {
			$length = filesize($filename);
			$fd = fopen($filename,'rb');

			if (!$fd) {
				$this->error = self::CANNOT_READ_FILE; // Probably permissions
			}
			$this->_str = fread($fd, $length);
			fclose($fd);
		} else {
			$this->error = self::FILE_DOES_NOT_EXIST;
		}
	}
}

I figure these kind of changes can help us stay ahead of deprecations and make maintaining the overall project easier in the long run.

i’m not really interested in any generic major “modernizing” of stuff that works.

however, there was this guy recently who wanted to make a full tt-rss rewrite, not sure if his project ever went anywhere but you can try looking him up.

we’re going to randomly rewrite things instead?

easier for whom? i’ve been maintaing tt-rss for about 15 years now and i can’t say it was hard - in the end it’s a rather simple CRUD app. not sure if this is a long enough run for you.

i don’t see how trying to conform to some arbitrary coding style - or whatever “PSR-12” is, i’m not entirely sure - is going to make things easier for me.

incidentally, which open source projects have you been maintaning? please provide some repository URLs.

Fair enough.

I maintain one open source project. It is a wrapper around the Authorize .Net payment gateway suite of APIs. There is PHP 5 compatible version and PHP 7.2 compatible version:

PHP 5 version: https://github.com/stymiee/authnetjson
PHP 7 version: https://github.com/stymiee/authnetjson/tree/php72