andela-cganga / potato-orm

src/Potato.php

<?php

namespace Ganga\Potato;

use ReflectionClass;
use PDO;

/**
 * Class that defines Potato ORM
 * Will be extended by Model Classes
 */
class Potato
{
    protected $tableName;
    protected static $id = null;
    protected static $table;
    protected $props = [];

    /**
     * Constructor
     * TableName is set when the class is extended
     */
    public function __construct()
    {
        /**
         * Tests if the Model has defined a table name
         * if not it assigns it to the name of the class
         */
        if (!$this->tableName) {
            $ref = new ReflectionClass($this);
            $tableName = strtolower($ref->getShortName()).'s';
        }

        // Test if table exists else throw an exception
        if (!self::tableExists($tableName)) {
            throw new PotatoException("Table $tableName does not exist.");
        } else {
            $this->tableName = $tableName;

The variable $tableName does not seem to be defined for all execution paths leading up to this point.

            self::$table = $tableName;
        }
    }

    public function __set($key, $value)
    {
        $this->props[$key] = $value;
    }

    /**
     * Checks if a given table exists in the database
     * @param  string $tableName name of the table to be checked
     * @return bool           true if table is found, false otherwise
     */
    public static function tableExists($tableName)
    {
        $query = "SELECT 1 FROM $tableName LIMIT 1";

        try {
            $result = Connection::db()->query($query);
        } catch (Exception $e) {

The class Ganga\Potato\Exception does not exist. Did you forget a USE statement, or did you not list all dependencies?

            return false;
        }

        return $result !== false;
    }

    /**
     * Get the name of the current table
     * @return String table name
     */
    public function getTableName()
    {
        return $this->tableName;
    }

    /**
     * Getting table names from a class
     * This is important when no instance of the class is defined
     * Like User::getAll()
     * @return string table name
     */
    public static function getTableNameFromClass()
    {
        $instance = new static();
        $ref = new ReflectionClass($instance);
        $name = $ref->getShortName();
        $table = strtolower($name) . 's';

        if (!self::tableExists($table)) {
            throw new PotatoException("Table $table does not exist.");
        }

        return $table;
    }

    /**
     * Get all records from the record table
     * @param array $fields array of fields to be retrieved
     * @return array associative array of the records received from the database
     */
    public static function getAll($fields = null)
    {
        $table = self::getTableNameFromClass();

        if ($fields != null && is_array($fields)) {

This code seems to be duplicated across your project.

            $query =  "SELECT ". implode(', ', $fields) ." FROM $table";
        } else {
            $query = "SELECT * FROM $table";
        }

        $res = [];

        $results = Connection::db()->query($query);
        $results->setFetchMode(PDO::FETCH_ASSOC);

        while ($row = $results->fetch()) {
            array_push($res, $row);
        }

        return $res;
    }

    /**
     * Get one record from the table based on the id provided
     * @param  integer $id id of the record to be retrieved
     * @param array $fields array of fields to be retrieved
     * @return array     associative array of the record retrieved
     */
    public static function getOne($id, $fields = null)
    {
        $table = self::getTableNameFromClass();

        if ($fields != null && is_array($fields)) {

This code seems to be duplicated across your project.

            $query = "SELECT ". implode(', ', $fields) ." FROM $table WHERE id = $id";
        } else {
            $query = "SELECT * FROM $table WHERE id = $id";
        }

        $res = [];

        $results = Connection::db()->query($query);
        $results->setFetchMode(PDO::FETCH_ASSOC);

        while ($row = $results->fetch()) {
            array_push($res, $row);
        }

        if (!empty($res)) {
            return $res;
        } else {
            throw new PotatoException('There is no user with id '. $id);
        }
    }

    /**
     * Save either a new or existing record
     * @return integer 1 is successful, 0 if false
     */
    public function save()
    {
        $result;

The variable $result seems only to be defined at a later point. Did you maybe move this code here without moving the variable definition?

        if (! self::$id) {
            // new record so we insert
            $query = "INSERT INTO $this->tableName (".implode(", ", array_keys($this->props)).") VALUES(";

            for ($i = 0; $i < count($this->props); $i++) {

It seems like you are calling the size function count() as part of the test condition. You might want to compute the size beforehand, and not on each iteration.

                $query .= "?";

                if ($i != count($this->props) - 1) {
                    $query .= ",";
                }
            }

            $query .= ");";

            $insert = Connection::db()->prepare($query);
            $result = $insert->execute(array_values($this->props));
        } else {
            // existing record, se we update
            $query = "UPDATE $this->tableName SET ";

            $count = 0;
            foreach ($this->props as $key => $value) {
                $query .= "$key = '$value'";

                if ($count != count($this->props) - 1) {
                    $query .= ",";
                }
                $count++;
            }

            $query .= " WHERE id = ".self::$id;
            $result = Connection::db()->query($query);
        }

        if (! $result) {
            return false;
        } else {
            return true;
        }
    }

    /**
     * Find a record by id and change static id param
     * @param  int $id id of the record to be found
     * @return ClassInstance     an instance of the TableClass so that properties can be assigned automatically
     */
    public static function find($id)
    {
        self::getOne($id);
        self::$id = $id;
        return new static();
    }

    /**
     * Delete a record by id from the table in context
     * @param  id $id the id of the record to be deleted
     * @return [type]     [description]

The doc-type [type] could not be parsed: Unknown type name "" at position 0. [(view supported doc-types)

     */
    public static function destroy($id)
    {
        $table = self::getTableNameFromClass();

        self::getOne($id);

        $query = "DELETE FROM $table WHERE id = ".$id;

        try {
            Connection::db()->query($query);
            return true;
        } catch (Exception $e) {

The class Ganga\Potato\Exception does not exist. Did you forget a USE statement, or did you not list all dependencies?

            return false;
        }
    }
}