fix: unset repo_name 💚️

Also remove the overwrite_files toggle.

.github/workflows/build.yml

@@ -0,0 +1,23 @@
+name: CI
+on:
+  push:
+    branches:
+      - "**"
+    tags:
+      - "!**"
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+     - uses: actions/checkout@v4
+     - name: Create Release Archive
+       id: semrelease
+       uses: go-semantic-release/action@v1
+       with:
+          # custom-arguments: --provider=gitea
+          hooks: exec
+       env:
+          GITEA_TOKEN: ${{ secrets.G_TOKEN }}
+          GITEA_HOST: ${{ secrets.G_SERVER_URL}}
+

.github/workflows/dist.yml

@@ -0,0 +1,22 @@
+name: Create Distribution
+run-name: Distribute composer package with Gitea Actions 🚀
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  dist:
+    name: Create Archive
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4  # Checkout Sourcecode
+      - uses: https://hub.cybercinch.nz/cybercinch/composer-build-action@v1
+      - uses: https://hub.cybercinch.nz/guisea/gitea-composer-upload-action@master
+        with:
+          baseurl: "${{ secrets.G_SERVER_URL}}"
+          access_token: "${{ secrets.G_TOKEN }}"
+          username: "${{ secrets.G_USERNAME }}"
+          owner: "cybercinch"  # Override owner name for repository (Optional) Only if different from username
+          version: "${{ env.GITHUB_REF_NAME }}"
+

.gitignore

@@ -0,0 +1,4 @@
+**/vendor
+tests/misc/*
+!tests/misc/cleanup.php
+!tests/misc/index.html

.semrelrc

@@ -0,0 +1,21 @@
+{
+  "plugins": {
+    "provider": {
+        "name": "gitea"
+    },
+    "changelog-generator": {
+        "name": "default",
+        "options": {
+          "emojis": "true"
+        }
+    },
+    "hooks": {
+      "names": [
+        "exec"
+      ],
+      "options": {
+        "exec_on_no_release": "echo {{.Reason}}: {{.Message}}"
+      }
+    }
+  }
+}

.travis.yml

@@ -1,5 +1,7 @@
 language: php
 
+sudo: false
+
 php:
   - 5.3.3
   - 5.3
@@ -8,9 +10,8 @@ php:
   - 5.6
 
 before_script:
-  - composer self-update
-  - composer update --prefer-source
-  - composer install --no-interaction --dev --prefer-source
+  - composer self-update 1.0.0-alpha10
+  - composer install --no-interaction --prefer-source
 
 script:
   - ./vendor/bin/phpunit

LICENSE

@@ -652,7 +652,7 @@ Also add information on how to contact you by electronic and paper mail.
   If the program does terminal interaction, make it output a short
 notice like this when it starts in an interactive mode:
 
-    {project}  Copyright (C) {year}  {fullname}
+    dcarbone/ugly-queue  Copyright (C) 2015  Daniel Paul Carbone
     This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
     This is free software, and you are welcome to redistribute it
     under certain conditions; type `show c' for details.

README.md

@@ -1,8 +1,91 @@
 ugly-queue
 ==========
 
-A simple file-based queue system for PHP 5.3.3+
+A simple file-based FIFO queue system for PHP 5.3.3+
 
-Build status: [![Build Status](https://travis-ci.org/dcarbone/ugly-queue.svg)](https://travis-ci.org/dcarbone/ugly-queue)
+Build status: [![Build Status](https://travis-ci.org/Cybercinch/ugly-queue.svg?branch=master)](https://travis-ci.org/Cybercinch/ugly-queue)
 
-Documentation and Test suites forthcoming.
+## Installation
+This library is designed to be installed into your app using [https://getcomposer.org/](Composer).
+Simply copy-paste the following line into your `"requires:"` hash:
+
+```json
+"dcarbone/ugly-queue": "0.4.*"
+```
+
+## Basic Usage
+Once installed, you must first initialize an instance of [src/UglyQueueManager.php](UglyQueueManager).
+This is done as such:
+
+```php
+$queueBaseDir = 'path to where you would like queue files and directories to be stored';
+
+$manager = new UglyQueueManager($queueBaseDir);
+```
+
+Once initialized, you can start adding queues!
+
+```php
+$sandwichQueue = $manager->createQueue('sandwiches');
+
+$sandwichQueue->lock();
+
+$sandwichQueue->addItems(array(
+    'bread',
+    'meat',
+    'cheese',
+    'lettuce',
+    'bread'
+));
+
+$sandwichQueue->unlock();
+```
+
+Once you have items added to the queue, you can either pull items out ad-hoc or set up some sort of cron
+or schedule task to process items regularly.
+
+If the base directory for all of your queues remains the same, each initialization
+of `UglyQueueManager` will automatically find and initialize instances of pre-existing
+UglyQueues.
+
+In a subsequent request, simply do the following:
+
+```php
+$queueBaseDir = 'path to where you would like queue files and directories to be stored';
+
+$manager = new UglyQueueManager($queueBaseDir);
+
+$tastySandwich = $manager->getQueue('sandwiches');
+
+// 'sandwiches' queue will exist now
+
+$tastySandwich->lock();
+
+// Specify the number of items you wish to retrieve from the queue
+
+$items = $tastySandwich->retrieveItems(4);
+
+// $items is now an array...
+
+var_export($items);
+
+/*
+array (
+  4 => 'bread',
+  3 => 'lettuce',
+  2 => 'cheese',
+  1 => 'meat',
+)
+*/
+
+```
+
+The queue will then retain a single item, `0 => 'bread'` as the 5th item left in the queue.
+
+At any time you can determine how many items remain in a queue by executing `count($queueObj);`
+
+There are a few limitations currently:
+
+1. This lib is designed for small values without much in the way of formatting or line breaks
+2. It is designed to be atomic, meaning that only one process can be adding / retrieving items from
+a queue at a time.  Reading actions (count, searching, etc) are NOT atomic, however.

composer.json

@@ -1,5 +1,5 @@
 {
-    "name" : "dcarbone/ugly-queue",
+    "name" : "cybercinch/ugly-queue",
     "type" : "library",
     "description" : "A simple file-based queue system for PHP 5.3.3+",
 
@@ -9,28 +9,32 @@
         "file queue",
         "ugly queue"
     ],
-    "homepage": "https://github.com/dcarbone/ugly-queue",
+    "homepage": "https://hub.cybercinch.nz/cybercinch/ugly-queue",
     "license": "GPLv3",
 
     "authors" : [
         {
             "name" : "Daniel Carbone",
             "email" : "daniel.p.carbone@gmail.com"
+        },
+        {
+            "name" : "Aaron Guise",
+            "email" : "aaron-composer@guise.net.nz"
         }
     ],
 
     "require" : {
-        "php" : ">=5.3.3",
-        "dcarbone/helpers" : "6.1.*"
+        "php" : ">=7.1",
+        "dcarbone/helpers" : "~6.1"
     },
 
     "require-dev" : {
-        "phpunit/phpunit": "4.1.*"
+        "phpunit/phpunit": "~9.6.21"
     },
 
     "autoload" : {
         "psr-4" : {
-            "DCarbone\\" : "src/"
+            "Cybercinch\\" : "src/"
         }
     }
 }

phpunit.xml.dist

@@ -17,6 +17,11 @@
         <exclude>./tests/misc</exclude>
     </testsuite>
 
+    <testsuite name="UglyQueueManager">
+        <directory>./tests/UglyQueueManager</directory>
+        <exclude>./tests/misc</exclude>
+    </testsuite>
+
     <filter>
         <whitelist addUncoveredFilesFromWhitelist="true">
             <directory suffix=".php">./src</directory>

scripts/build.sh

@@ -0,0 +1,32 @@
+#!/bin/bash
+
+mkdir -p ./build/
+echo "Made temporary directory"
+
+# Package up the release (Needs to be .zip for upload to gitea)
+
+zip -r "./build/Package.zip" \
+    . \
+    -x '.semrel/*' \
+    -x '.generated-go-semantic-release-changelog.md' \
+    -x './vendor/*' \
+    -x './tests/*' \
+    -x './build/*' \
+    -x './.git/*' \
+    -x './.idea/*' \
+    -x './.github/*' \
+    -x './scripts/*'
+
+#RELEASE_ID=$(curl --silent -X 'GET' "${GITEA_HOST}/api/v1/repos/cybercinch/ugly-queue/releases/latest" \
+#-H "accept: application/json" \
+#-H "Authorization: token ${GITEA_TOKEN}" | jq -r .id)
+#
+## Attach to release
+#curl --silent -X 'POST' "${GITEA_HOST}/api/v1/repos/cybercinch/ugly-queue/releases/${RELEASE_ID}/assets?name=ugly-queue-${1}.tar.gz" \
+#-H "Authorization: token ${GITEA_TOKEN}" \
+#--form attachment="@build/ugly-queue-${1}.tar.gz"
+
+# Upload the artifact to composer registry
+curl --user "cibot:${GITEA_TOKEN}" \
+     --upload-file "build/ugly-queue.zip" \
+     "${GITEA_HOST}/api/packages/cybercinch/composer?version=${1}"

src/UglyQueue.php

@@ -1,50 +1,74 @@
-<?php namespace DCarbone;
+<?php namespace Cybercinch;
 
 use DCarbone\Helpers\FileHelper;
 
 /**
  * Class UglyQueue
- * @package DCarbone
+ * @package Cybercinch
  */
-class UglyQueue
+class UglyQueue implements \Serializable, \SplSubject, \Countable
 {
-    /** @var array */
-    protected $config;
+    const QUEUE_READONLY = 0;
+    const QUEUE_READWRITE = 1;
+
+    /** @var int */
+    private $_notifyStatus;
+
+    /** @var \SplObserver[] */
+    private $_observers = array();
+
+    /** @var int */
+    protected $mode = null;
 
     /** @var string */
-    protected $queueBaseDir;
+    protected $baseDir;
 
     /** @var string */
-    protected $queueGroup = null;
+    protected $name;
 
     /** @var string */
-    protected $queueGroupDirPath = null;
+    protected $path;
 
     /** @var bool */
-    protected $haveLock = false;
-
-    /** @var bool */
-    protected $init = false;
+    protected $locked = false;
 
     /** @var resource */
-    protected $_tmpHandle;
+    protected $tmpHandle;
+
+    /** @var string */
+    protected $queueFile;
+
+    /** @var string */
+    protected $queueTmpFile;
+
+    /** @var string */
+    protected $lockFile;
+
+    /** @var string */
+    protected $serializeFile;
 
     /**
-     * @param array $config
-     * @throws \RuntimeException
-     * @throws \InvalidArgumentException
+     * @param string $baseDir
+     * @param string $name
+     * @param \SplObserver[] $observers
      */
-    public function __construct(array $config)
+    public function __construct($baseDir, $name, array $observers = array())
     {
-        if (!isset($config['queue-base-dir']))
-            throw new \InvalidArgumentException('UglyQueue::__construct - "$config" parameter "queue-base-dir" not seen.');
+        $this->baseDir = realpath($baseDir);
+        $this->name = $name;
+        $this->_observers = $observers;
 
-        if (!is_dir($config['queue-base-dir']) || !is_writable($config['queue-base-dir']))
-            throw new \RuntimeException('UglyQueue::__construct - "$config[\'queue-base-dir\']" points to a directory that either doesn\'t exist or is not writable');
+        $path = sprintf('%s%s%s', $baseDir, DIRECTORY_SEPARATOR, $name);
+        if (!file_exists($path) && !@mkdir($path))
+            throw new \RuntimeException('Unable to initialize queue directory "'.$path.'".  Please check permissions.');
 
-        $this->config = $config;
+        $this->path = $path;
+        $this->lockFile = sprintf('%s%squeue.lock', $path, DIRECTORY_SEPARATOR);
+        $this->queueFile = sprintf('%s%squeue.txt', $path, DIRECTORY_SEPARATOR);
+        $this->queueTmpFile = sprintf('%s%squeue.tmp', $path, DIRECTORY_SEPARATOR);
+        $this->serializeFile = sprintf('%s%sugly-queue.obj', $path, DIRECTORY_SEPARATOR);
 
-        $this->queueBaseDir = $this->config['queue-base-dir'];
+        $this->initialize();
     }
 
     /**
@@ -52,8 +76,81 @@ class UglyQueue
      */
     public function __destruct()
     {
-        $this->unlock();
         $this->_populateQueue();
+        $this->unlock();
+        file_put_contents($this->path.'/ugly-queue.obj', serialize($this));
+    }
+
+    /**
+     * @return string
+     */
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    /**
+     * @return int
+     */
+    public function getMode()
+    {
+        return $this->mode;
+    }
+
+    /**
+     * @return string
+     */
+    public function getPath()
+    {
+        return $this->path;
+    }
+
+    /**
+     * @return string
+     */
+    public function getBaseDir()
+    {
+        return $this->baseDir;
+    }
+
+    /**
+     * @return string
+     */
+    public function getQueueFile()
+    {
+        return $this->queueFile;
+    }
+
+    /**
+     * @return string
+     */
+    public function getQueueTmpFile()
+    {
+        return $this->queueTmpFile;
+    }
+
+    /**
+     * @return string
+     */
+    public function getLockFile()
+    {
+        return $this->lockFile;
+    }
+
+    /**
+     * @return string
+     */
+    public function getSerializeFile()
+    {
+        return $this->serializeFile;
+    }
+
+    /**
+     * @return boolean
+     */
+    public function isLocked()
+    {
+        return $this->locked;
     }
 
     /**
@@ -64,36 +161,21 @@ class UglyQueue
     public function lock($ttl = 250)
     {
         if (!is_int($ttl))
-            throw new \InvalidArgumentException('UglyQueue::lock - Argument 1 expected to be positive integer, "'.gettype($ttl).'" seen');
+            throw new \InvalidArgumentException('Argument 1 expected to be integer, "'.gettype($ttl).'" seen');
 
-        if ($ttl < 0)
-            throw new \InvalidArgumentException('UglyQueue::lock - Argument 1 expected to be positive integer, "'.$ttl.'" seen');
+        if ($ttl < 1)
+            throw new \InvalidArgumentException('Argument 1 expected to be greater than 0 "'.$ttl.'" seen');
 
-        $already_locked = $this->isLocked();
-
-        // If there is no lock, currently
-        if ($already_locked === false)
-            return $this->haveLock = $this->createQueueLock($ttl);
+        // If there is currently no lock
+        if ($this->isAlreadyLocked() === false)
+            return $this->createLockFile($ttl);
 
         // If we make it this far, there is already a lock in place.
-        return $this->haveLock = false;
-    }
+        $this->locked = false;
+        $this->_notifyStatus = UglyQueueEnum::QUEUE_LOCKED_BY_OTHER_PROCESS;
+        $this->notify();
 
-    /**
-     * @param int $ttl seconds to live
-     * @return bool
-     */
-    protected function createQueueLock($ttl)
-    {
-        $ok = (bool)@file_put_contents(
-            $this->queueGroupDirPath.'queue.lock',
-            json_encode(array('ttl' => $ttl, 'born' => time())));
-
-        if ($ok !== true)
-            return false;
-
-        $this->haveLock = true;
-        return true;
+        return false;
     }
 
     /**
@@ -101,10 +183,13 @@ class UglyQueue
      */
     public function unlock()
     {
-        if ($this->haveLock === true)
+        if ($this->isLocked() === true)
         {
-            unlink($this->queueGroupDirPath.'queue.lock');
-            $this->haveLock = false;
+            unlink($this->lockFile);
+            $this->locked = false;
+
+            $this->_notifyStatus = UglyQueueEnum::QUEUE_UNLOCKED;
+            $this->notify();
         }
     }
 
@@ -112,30 +197,26 @@ class UglyQueue
      * @throws \RuntimeException
      * @return bool
      */
-    public function isLocked()
+    public function isAlreadyLocked()
     {
-        if ($this->init === false)
-            throw new \RuntimeException('UglyQueue::isLocked - Must first initialize queue');
-
         // First check for lock file
-        if (is_file($this->queueGroupDirPath.'queue.lock'))
+        if (is_file($this->lockFile))
         {
-            $lock = json_decode(file_get_contents($this->queueGroupDirPath.'queue.lock'), true);
+            $lock = json_decode(file_get_contents($this->lockFile), true);
 
-            // If we have an invalid lock structure, THIS IS BAD.
-            if (!isset($lock['ttl']) || !isset($lock['born']))
-                throw new \RuntimeException('UglyQueue::isLocked - Invalid "queue.lock" file structure seen at "'.$this->queueGroupDirPath.'queue.lock'.'"');
+            // If the decoded lock file contains a ttl and born value...
+            if (isset($lock['ttl']) && isset($lock['born']))
+            {
+                $lock_ttl = ((int)$lock['born'] + (int)$lock['ttl']);
 
-            // Otherwise...
-            $lock_ttl = ((int)$lock['born'] + (int)$lock['ttl']);
-
-            // If we're within the TTL of the lock, assume another thread is already processing.
-            // We'll pick it up on the next go around.
-            if ($lock_ttl > time())
-                return true;
+                // If we're within the TTL of the lock, assume another thread is already processing.
+                // We'll pick it up on the next go around.
+                if ($lock_ttl > time())
+                    return true;
+            }
 
             // Else, remove lock file and assume we're good to go!
-            unlink($this->queueGroupDirPath.'queue.lock');
+            unlink($this->lockFile);
             return false;
         }
 
@@ -143,72 +224,44 @@ class UglyQueue
         return false;
     }
 
-    /**
-     * @param string $queueGroup
-     */
-    public function initialize($queueGroup)
-    {
-        $this->queueGroup = $queueGroup;
-        $this->queueGroupDirPath = $this->queueBaseDir.$queueGroup.DIRECTORY_SEPARATOR;
-
-        // Create directory for this queue group
-        if (!is_dir($this->queueGroupDirPath))
-            mkdir($this->queueGroupDirPath);
-
-        // Insert "don't look here" index.html file
-        if (!file_exists($this->queueGroupDirPath.'index.html'))
-        {
-            $html = <<<HTML
-<html>
-<head>
-	<title>403 Forbidden</title>
-</head>
-<body>
-<p>Directory access is forbidden.</p>
-</body>
-</html>
-HTML;
-            file_put_contents($this->queueGroupDirPath.'index.html', $html);
-        }
-
-        if (!file_exists($this->queueGroupDirPath.'queue.txt'))
-            file_put_contents($this->queueGroupDirPath.'queue.txt', '');
-
-        $this->init = true;
-    }
-
     /**
      * @param int $count
      * @throws \RuntimeException
      * @throws \InvalidArgumentException
      * @return bool|array
      */
-    public function processQueue($count = 1)
+    public function retrieveItems($count = 1)
     {
-        if ($this->init === false)
-            throw new \RuntimeException('UglyQueue::processQueue - Must first initialize queue!');
+        if ($this->mode === self::QUEUE_READONLY)
+            throw new \RuntimeException('Queue "'.$this->name.'" cannot be processed. It was started in Read-Only mode (the user running this process does not have permission to write to the queue directory).');
 
         // If we don't have a lock, assume issue and move on.
-        if ($this->haveLock === false)
-            throw new \RuntimeException('UglyQueue::processQueue - Cannot process queue locked by another process');
+        if ($this->isLocked() === false)
+            throw new \RuntimeException('Cannot process queue named "'.$this->name.'".  It is locked by another process.');
 
         // If non-int valid is passed
         if (!is_int($count))
-            throw new \InvalidArgumentException('UglyQueue::processQueue - Argument 1 expected to be integer greater than 0, "'.gettype($count).'" seen');
+            throw new \InvalidArgumentException('Argument 1 expected to be integer greater than 0, "'.gettype($count).'" seen');
 
         // If negative integer passed
         if ($count <= 0)
-            throw new \InvalidArgumentException('UglyQueue::processQueue - Argument 1 expected to be integer greater than 0, "'.$count.'" seen');
+            throw new \InvalidArgumentException('Argument 1 expected to be integer greater than 0, "'.$count.'" seen');
+
+        if ($this->_notifyStatus !== UglyQueueEnum::QUEUE_PROCESSING)
+        {
+            $this->_notifyStatus = UglyQueueEnum::QUEUE_PROCESSING;
+            $this->notify();
+        }
 
         // Find number of lines in the queue file
-        $lineCount  = FileHelper::getLineCount($this->queueGroupDirPath.'queue.txt');
+        $lineCount  = count($this);
 
         // If queue line count is 0, assume empty
         if ($lineCount === 0)
             return false;
 
         // Try to open the file for reading / writing.
-        $queueFileHandle = fopen($this->queueGroupDirPath.'queue.txt', 'r+');
+        $queueFileHandle = fopen($this->queueFile, 'r+');
         if ($queueFileHandle === false)
             $this->unlock();
 
@@ -216,12 +269,12 @@ HTML;
         $data = array();
         $start_line = $lineCount - $count;
         $i = 0;
-        while (($line = fscanf($queueFileHandle, "%s\t%s\n")) !== false && $i < $lineCount)
+        while (($line = fscanf($queueFileHandle, "%s\t%[^\n]")) !== false && $i < $lineCount)
         {
             if ($i++ >= $start_line)
             {
                 list ($key, $value) = $line;
-                $data[$key] = $value;
+                $data = array($key => $value) + $data;
             }
         }
 
@@ -231,11 +284,14 @@ HTML;
             rewind($queueFileHandle);
             ftruncate($queueFileHandle, 0);
             fclose($queueFileHandle);
+
+            $this->_notifyStatus = UglyQueueEnum::QUEUE_REACHED_END;
+            $this->notify();
         }
         // Otherwise, create new queue file minus the processed lines.
         else
         {
-            $tmp = fopen($this->queueGroupDirPath.'queue.tmp', 'w+');
+            $tmp = fopen($this->queueTmpFile, 'w+');
             rewind($queueFileHandle);
             $i = 0;
             while (($line = fgets($queueFileHandle)) !== false && $i < $start_line)
@@ -248,8 +304,8 @@ HTML;
 
             fclose($queueFileHandle);
             fclose($tmp);
-            unlink($this->queueGroupDirPath.'queue.txt');
-            rename($this->queueGroupDirPath.'queue.tmp', $this->queueGroupDirPath.'queue.txt');
+            unlink($this->queueFile);
+            rename($this->queueTmpFile, $this->queueFile);
         }
 
         return $data;
@@ -261,31 +317,42 @@ HTML;
      * @return bool
      * @throws \RuntimeException
      */
-    public function addToQueue($key, $value)
+    public function addItem($key, $value)
     {
-        if ($this->init === false)
-            throw new \RuntimeException('UglyQueue::addToQueue - Must first initialize queue!');
+        if ($this->mode === self::QUEUE_READONLY)
+            throw new \RuntimeException('Cannot add item to queue "'.$this->name.'" as it is in read-only mode');
 
         // If we don't have a lock, assume issue and move on.
-        if ($this->haveLock === false)
-            throw new \RuntimeException('UglyQueue::addToQueue - You do not have a lock on this queue');
+        if ($this->isLocked() === false)
+            throw new \RuntimeException('Cannot add item to queue "'.$this->name.'". Queue is already locked by another process');
 
-        if (!is_resource($this->_tmpHandle))
+        if (!is_resource($this->tmpHandle))
         {
-            $this->_tmpHandle = fopen($this->queueGroupDirPath.'queue.tmp', 'w+');
-            if ($this->_tmpHandle === false)
-                throw new \RuntimeException('UglyQueue::addToQueue - Unable to create "queue.tmp" file');
+            $this->tmpHandle = fopen($this->queueTmpFile, 'w+');
+            if ($this->tmpHandle === false)
+                throw new \RuntimeException('Unable to create "queue.tmp" file.');
         }
 
         if (is_array($value) || $value instanceof \stdClass)
             $value = json_encode($value);
 
         return (bool)fwrite(
-            $this->_tmpHandle,
+            $this->tmpHandle,
             $key."\t".str_replace(array("\r\n", "\n"), ' ', $value)
             ."\n");
     }
 
+    /**
+     * @param array $items
+     */
+    public function addItems(array $items)
+    {
+        foreach($items as $k=>$v)
+        {
+            $this->addItem($k, $v);
+        }
+    }
+
     /**
      * If there is a tmp queue file, add it's contents to the beginning of a new queue file
      *
@@ -293,38 +360,26 @@ HTML;
      */
     public function _populateQueue()
     {
-        if (is_resource($this->_tmpHandle))
+        if (is_resource($this->tmpHandle))
         {
-            if (file_exists($this->queueGroupDirPath.'queue.txt'))
+            if (file_exists($this->queueFile))
             {
-                $queueFileHandle = fopen($this->queueGroupDirPath.'queue.txt', 'r+');
+                $queueFileHandle = fopen($this->queueFile, 'r+');
                 while (($line = fgets($queueFileHandle)) !== false)
                 {
                     if ($line !== "\n" && $line !== "")
-                        fwrite($this->_tmpHandle, $line);
+                        fwrite($this->tmpHandle, $line);
                 }
 
                 fclose($queueFileHandle);
-                unlink($this->queueGroupDirPath.'queue.txt');
+                unlink($this->queueFile);
             }
 
-            fclose($this->_tmpHandle);
-            rename($this->queueGroupDirPath.'queue.tmp', $this->queueGroupDirPath.'queue.txt');
+            fclose($this->tmpHandle);
+            rename($this->queueTmpFile, $this->queueFile);
         }
     }
 
-    /**
-     * @return int
-     * @throws \RuntimeException
-     */
-    public function getQueueItemCount()
-    {
-        if ($this->init === false)
-            throw new \RuntimeException('UglyQueue::getQueueItemCount - Must first initialize queue');
-
-        return FileHelper::getLineCount($this->queueGroupDirPath.'queue.txt');
-    }
-
     /**
      * @param string $key
      * @return bool
@@ -332,19 +387,14 @@ HTML;
      */
     public function keyExistsInQueue($key)
     {
-        if ($this->init === false)
-            throw new \RuntimeException('UglyQueue::keyExistsInQueue - Must first initialize queue');
-
         $key = (string)$key;
 
         // Try to open the file for reading / writing.
-        $queueFileHandle = fopen($this->queueGroupDirPath.'queue.txt', 'r');
+        $queueFileHandle = fopen($this->queueFile, 'r');
 
-        while(($line = fscanf($queueFileHandle, "%s\t")) !== false)
+        while(($line = fscanf($queueFileHandle, "%s\t%s\n")) !== false)
         {
-            list($queueKey) = $line;
-
-            if ($key === $queueKey)
+            if ($key === $line[0])
             {
                 fclose($queueFileHandle);
                 return true;
@@ -356,59 +406,189 @@ HTML;
     }
 
     /**
-     * @param string $groupName
+     * (PHP 5 >= 5.1.0)
+     * Count elements of an object
+     * @link http://php.net/manual/en/countable.count.php
+     *
+     * @return int The custom count as an integer.
+     */
+    public function count()
+    {
+        return (int)FileHelper::getLineCount($this->queueFile);
+    }
+
+    /**
+     * (PHP 5 >= 5.1.0)
+     * String representation of object
+     * @link http://php.net/manual/en/serializable.serialize.php
+     *
+     * @return string the string representation of the object or null
+     */
+    public function serialize()
+    {
+        return serialize(
+            array(
+                $this->baseDir,
+                $this->name,
+                $this->path,
+                $this->queueFile,
+                $this->queueTmpFile,
+                $this->lockFile,
+                $this->serializeFile,
+            )
+        );
+    }
+
+    /**
+     * (PHP 5 >= 5.1.0)
+     * Constructs the object
+     * @link http://php.net/manual/en/serializable.unserialize.php
+     *
+     * @param string $serialized The string representation of the object.
+     * @return void
+     */
+    public function unserialize($serialized)
+    {
+        $data = unserialize($serialized);
+        $this->baseDir = $data[0];
+        $this->name = $data[1];
+        $this->path = $data[2];
+        $this->queueFile = $data[3];
+        $this->queueTmpFile = $data[4];
+        $this->lockFile = $data[5];
+        $this->serializeFile = $data[6];
+        $this->initialize();
+    }
+
+    /**
+     * (PHP 5 >= 5.1.0)
+     * Attach an SplObserver
+     * @link http://php.net/manual/en/splsubject.attach.php
+     *
+     * @param \SplObserver $observer The SplObserver to attach.
+     * @return void
+     */
+    public function attach(\SplObserver $observer)
+    {
+        if (!in_array($observer, $this->_observers))
+            $this->_observers[] = $observer;
+    }
+
+    /**
+     * (PHP 5 >= 5.1.0)
+     * Detach an observer
+     * @link http://php.net/manual/en/splsubject.detach.php
+     *
+     * @param \SplObserver $observer The SplObserver to detach.
+     * @return void
+     */
+    public function detach(\SplObserver $observer)
+    {
+        $idx = array_search($observer, $this->_observers, true);
+        if ($idx !== false)
+            unset($this->_observers[$idx]);
+    }
+
+    /**
+     * (PHP 5 >= 5.1.0)
+     * Notify an observer
+     * @link http://php.net/manual/en/splsubject.notify.php
+     *
+     * @return void
+     */
+    public function notify()
+    {
+        foreach($this->_observers as $observer)
+        {
+            $observer->update($this);
+        }
+    }
+
+    /**
+     * This method is mostly intended to check the "validity" of a re-initialized queue
+     *
+     * Could probably stand to be improved.
+     *
      * @return bool
      */
-    public function queueExists($groupName)
+    public function _valid()
     {
-        return (bool)is_dir($this->queueBaseDir.$groupName);
+        return (
+            $this->baseDir !== null &&
+            $this->name !== null &&
+            $this->path !== null &&
+            $this->queueFile !== null &&
+            $this->queueTmpFile !== null &&
+            $this->lockFile !== null &&
+            $this->serializeFile !== null
+        );
     }
 
+    // --------
+
     /**
-     * @return array
+     * @param int $ttl seconds to live
+     * @return bool
      */
-    public function getInitializedQueueList()
+    protected function createLockFile($ttl)
     {
-        $queueList = array();
-        foreach(glob(realpath($this->queueBaseDir).DIRECTORY_SEPARATOR.'*', GLOB_ONLYDIR) as $queueDir)
+        $ok = (bool)@file_put_contents(
+            $this->lockFile,
+            json_encode(array('ttl' => $ttl, 'born' => time())));
+
+        if ($ok !== true)
         {
-            $exp = explode(DIRECTORY_SEPARATOR, $queueDir);
-            $dir = end($exp);
-            if (strpos($dir, '.') !== 0)
-                $queueList[] = $dir;
+            $this->_notifyStatus = UglyQueueEnum::QUEUE_FAILED_TO_LOCK;
+            $this->notify();
+            return $this->locked = false;
         }
-        return $queueList;
+
+        $this->locked = true;
+        $this->_notifyStatus = UglyQueueEnum::QUEUE_LOCKED;
+        $this->notify();
+
+        return true;
     }
 
     /**
-     * @return boolean
+     * Post-construct initialization method.
+     *
+     * Also used post-un-serialization
      */
-    public function getInit()
+    protected function initialize()
     {
-        return $this->init;
-    }
+        if (is_readable($this->path) && is_writable($this->path))
+            $this->mode = self::QUEUE_READWRITE;
+        else if (is_readable($this->path))
+            $this->mode = self::QUEUE_READONLY;
 
-    /**
-     * @return string
-     */
-    public function getQueueBaseDir()
-    {
-        return $this->queueBaseDir;
-    }
+        if (!file_exists($this->path.'/index.html'))
+        {
+            if ($this->mode === self::QUEUE_READONLY)
+                throw new \RuntimeException('Cannot initialize queue with name "'.$this->name.'", the user lacks permission to create files.');
 
-    /**
-     * @return string
-     */
-    public function getQueueGroupDirPath()
-    {
-        return $this->queueGroupDirPath;
-    }
+            $html = <<<HTML
+<html>
+<head>
+	<title>403 Forbidden</title>
+</head>
+<body>
+    <p>Directory access is forbidden.</p>
+</body>
+</html>
+HTML;
+            file_put_contents($this->path.'/index.html', $html);
+        }
 
-    /**
-     * @return string
-     */
-    public function getQueueGroup()
-    {
-        return $this->queueGroup;
+        if (!file_exists($this->queueFile))
+        {
+            if ($this->mode === self::QUEUE_READONLY)
+                throw new \RuntimeException('Cannot initialize queue with name "'.$this->name.'", the user lacks permission to create files.');
+
+            file_put_contents($this->queueFile, '');
+        }
+
+        $this->_notifyStatus = UglyQueueEnum::QUEUE_INITIALIZED;
+        $this->notify();
     }
 }

src/UglyQueueEnum.php

@@ -0,0 +1,24 @@
+<?php namespace Cybercinch;
+
+/**
+ * Class UglyQueueEnum
+ * @package Cybercinch
+ *
+ * Pseudo-enum thing.
+ */
+abstract class UglyQueueEnum
+{
+    // Typically used by UglyQueueManager
+    const MANAGER_INITIALIZED = 1;
+    const QUEUE_ADDED = 2;
+    const QUEUE_REMOVED = 3;
+
+    // Typically used by UglyQueues
+    const QUEUE_INITIALIZED              = 100;
+    const QUEUE_LOCKED                   = 101;
+    const QUEUE_FAILED_TO_LOCK           = 102;
+    const QUEUE_LOCKED_BY_OTHER_PROCESS  = 103;
+    const QUEUE_UNLOCKED                 = 104;
+    const QUEUE_PROCESSING               = 105;
+    const QUEUE_REACHED_END              = 106;
+}

src/UglyQueueManager.php

@@ -0,0 +1,193 @@
+<?php namespace Cybercinch;
+
+use InvalidArgumentException;
+
+/**
+ * Class UglyQueueManager
+ * @package Cybercinch
+ */
+class UglyQueueManager implements \SplObserver, \Countable
+{
+    /** @var UglyQueue[] */
+    protected $queues = array();
+
+    /** @var string */
+    protected $baseDir;
+
+    /**
+     * Constructor
+     *
+     * @param string $baseDir
+     * @throws \RuntimeException
+     * @throws InvalidArgumentException
+     */
+    public function __construct($baseDir)
+    {
+        if (false === is_string($baseDir))
+            throw new InvalidArgumentException('Argument 1 expected to be string, "'.gettype($baseDir).'" seen.');
+
+        if (false === is_dir($baseDir))
+            throw new \RuntimeException('"'.$baseDir.'" points to a directory that does not exist.');
+
+        if (false === is_readable($baseDir))
+            throw new \RuntimeException('"'.$baseDir.'" is not readable and/or writable .');
+
+        $this->baseDir =  rtrim($baseDir, "/\\");
+
+        foreach(glob(sprintf('%s/*', $this->baseDir), GLOB_ONLYDIR) as $queueDir)
+        {
+            $this->addQueueAtPath($queueDir);
+        }
+    }
+
+    /**
+     * @param string $name
+     * @return UglyQueue
+     */
+    public function getQueue($name)
+    {
+        if (isset($this->queues[$name]))
+            return $this->queues[$name];
+
+        $path = sprintf('%s/%s', $this->baseDir, $name);
+        if (file_exists($path))
+            return $this->addQueueAtPath($path);
+
+        return $this->createQueue($name);
+    }
+
+    /**
+     * @param UglyQueue $uglyQueue
+     * @return UglyQueueManager
+     * @throws \RuntimeException
+     */
+    public function addQueue(UglyQueue $uglyQueue)
+    {
+        $name = $uglyQueue->getName();
+
+        if ($this->containsQueueWithName($name))
+            throw new \RuntimeException('Queue named "'.$name.'" already exists in this manager.');
+
+        $this->queues[$name] = $uglyQueue;
+
+        return $this;
+    }
+
+    /**
+     * @param string $name
+     * @return UglyQueue
+     */
+    public function createQueue($name)
+    {
+        $queue = new UglyQueue($this->baseDir, $name, array($this));
+        $this->addQueue($queue);
+        return end($this->queues);
+    }
+
+    /**
+     * @param string $path
+     * @return \DCarbone\UglyQueueManager
+     */
+    public function addQueueAtPath($path)
+    {
+        // Try to avoid looking at hidden directories or magic dirs such as '.' and '..'
+        $split = preg_split('#[/\\\]+#', $path);
+
+        $queueName = end($split);
+
+        if (0 === strpos($queueName, '.'))
+            return null;
+
+        $serializedFile = sprintf('%s/%s/ugly-queue.obj', $this->baseDir, $queueName);
+        /** @var \DCarbone\UglyQueue $uglyQueue */
+        if (file_exists($serializedFile))
+            $uglyQueue = unserialize(file_get_contents($serializedFile));
+
+        if (!isset($uglyQueue) || $uglyQueue->_valid() === false)
+            $uglyQueue = new UglyQueue($this->baseDir, $queueName, array($this));
+
+        $uglyQueue->attach($this);
+
+        return $this->addQueue($uglyQueue);
+    }
+
+    /**
+     * @param UglyQueue $uglyQueue
+     * @return UglyQueueManager
+     */
+    public function removeQueue(UglyQueue $uglyQueue)
+    {
+        $name = $uglyQueue->getName();
+        if ($this->containsQueueWithName($name))
+            unset($this->queues[$name]);
+
+        return $this;
+    }
+
+    /**
+     * @param string $name
+     * @return UglyQueueManager
+     */
+    public function removeQueueByName($name)
+    {
+        if ($this->containsQueueWithName($name))
+            unset($this->queues[$name]);
+
+        return $this;
+    }
+
+    /**
+     * @param string $name
+     * @return UglyQueue
+     * @throws InvalidArgumentException
+     */
+    public function getQueueWithName($name)
+    {
+        if (isset($this->queues[$name]))
+            return $this->queues[$name];
+
+        throw new InvalidArgumentException('Argument 1 expected to be valid queue name.');
+    }
+
+    /**
+     * @param string $name
+     * @return bool
+     */
+    public function containsQueueWithName($name)
+    {
+        return isset($this->queues[$name]);
+    }
+
+    /**
+     * @return array
+     */
+    public function getQueueList()
+    {
+        return array_keys($this->queues);
+    }
+
+    /**
+     * (PHP 5 >= 5.1.0)
+     * Count elements of an object
+     * @link http://php.net/manual/en/countable.count.php
+     *
+     * @return int The custom count as an integer. The return value is cast to an integer.
+     */
+    public function count()
+    {
+        return count($this->queues);
+    }
+
+    /**
+     * (PHP 5 >= 5.1.0)
+     * Receive update from subject
+     * @link http://php.net/manual/en/splobserver.update.php
+     *
+     * @param \SplSubject $subject The SplSubject notifying the observer of an update.
+     * @return void
+     */
+    public function update(\SplSubject $subject)
+    {
+        // Nothing for now...
+    }
+}

tests/UglyQueue/UglyQueueTest.php

@@ -7,8 +7,10 @@ require_once __DIR__.'/../misc/cleanup.php';
 /**
  * Class UglyQueueTest
  */
-class UglyQueueTest extends PHPUnit_Framework_TestCase
+class UglyQueueTest extends PHPUnit\Framework\TestCase
 {
+    protected $baseDir;
+
     /**
      * @var array
      */
@@ -26,349 +28,265 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
         '10' => 'Virginia baked ham, sliced',
     );
 
-    /**
-     * @covers \DCarbone\UglyQueue::__construct
-     * @uses \DCarbone\UglyQueue
-     * @return \DCarbone\UglyQueue
-     */
-    public function testCanConstructUglyQueueWithValidParameter()
+    protected function setUp(): void
     {
-        $conf = array(
-            'queue-base-dir' => dirname(__DIR__).'/misc/',
-        );
+        $this->baseDir = realpath(__DIR__.'/../misc/queues');
+    }
 
-        $uglyQueue = new \DCarbone\UglyQueue($conf);
+    /**
+     * @covers \Cybercinch\UglyQueue::__construct
+     * @uses \Cybercinch\UglyQueue
+     * @return \Cybercinch\UglyQueue
+     */
+    public function testCanInitializeObjectWithValidParameters()
+    {
+        $uglyQueue = new \Cybercinch\UglyQueue($this->baseDir, 'tasty-sandwich');
 
-        $this->assertInstanceOf('\\DCarbone\\UglyQueue', $uglyQueue);
+        $this->assertInstanceOf('\\Cybercinch\\UglyQueue', $uglyQueue);
 
         return $uglyQueue;
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::__construct
-     * @uses \DCarbone\UglyQueue
-     * @expectedException \InvalidArgumentException
+     * @covers \Cybercinch\UglyQueue::retrieveItems
+     * @uses \Cybercinch\UglyQueue
+     * @depends testCanInitializeObjectWithValidParameters
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testExceptionThrownWhenConstructingUglyQueueWithEmptyOrInvalidConf()
+    public function testExceptionThrownWhenTryingToProcessQueueAfterInitializationBeforeLock(\Cybercinch\UglyQueue $uglyQueue)
     {
-        $conf = array();
-        $uglyQueue = new \DCarbone\UglyQueue($conf);
+        $this->expectException(\RuntimeException::class);
+        $uglyQueue->retrieveItems();
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::__construct
-     * @uses \DCarbone\UglyQueue
-     * @expectedException \RuntimeException
+     * @covers \Cybercinch\UglyQueue::keyExistsInQueue
+     * @uses \Cybercinch\UglyQueue
+     * @depends testCanInitializeObjectWithValidParameters
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testExceptionThrownWhenConstructingUglyQueueWithInvalidQueueBaseDirPath()
-    {
-        $conf = array(
-            'queue-base-dir' => 'sandwiches',
-        );
-
-        $uglyQueue = new \DCarbone\UglyQueue($conf);
-    }
-
-    /**
-     * @covers \DCarbone\UglyQueue::getQueueBaseDir
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanConstructUglyQueueWithValidParameter
-     * @param \DCarbone\UglyQueue $uglyQueue
-     */
-    public function testCanGetQueueBaseDir(\DCarbone\UglyQueue $uglyQueue)
-    {
-        $queueBaseDir = $uglyQueue->getQueueBaseDir();
-
-        $this->assertFileExists(
-            $queueBaseDir,
-            'Could not verify that Queue Base Dir exists');
-    }
-
-    /**
-     * @covers \DCarbone\UglyQueue::getQueueGroup
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanConstructUglyQueueWithValidParameter
-     * @param \DCarbone\UglyQueue $uglyQueue
-     */
-    public function testGetQueueGroupReturnsNullBeforeInitialization(\DCarbone\UglyQueue $uglyQueue)
-    {
-        $queueGroup = $uglyQueue->getQueueGroup();
-
-        $this->assertNull($queueGroup);
-    }
-
-    /**
-     * @covers \DCarbone\UglyQueue::getInit
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanConstructUglyQueueWithValidParameter
-     * @param \DCarbone\UglyQueue $uglyQueue
-     */
-    public function testGetInitReturnsFalseBeforeInitialization(\DCarbone\UglyQueue $uglyQueue)
-    {
-        $init = $uglyQueue->getInit();
-        $this->assertFalse($init);
-    }
-
-    /**
-     * @covers \DCarbone\UglyQueue::getQueueGroupDirPath
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanConstructUglyQueueWithValidParameter
-     * @param \DCarbone\UglyQueue $uglyQueue
-     */
-    public function testGetQueueGroupDirPathReturnsNullBeforeInitialization(\DCarbone\UglyQueue $uglyQueue)
-    {
-        $queueGroupDir = $uglyQueue->getQueueGroupDirPath();
-
-        $this->assertNull($queueGroupDir);
-    }
-
-    /**
-     * @covers \DCarbone\UglyQueue::isLocked
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanConstructUglyQueueWithValidParameter
-     * @expectedException \RuntimeException
-     * @param \DCarbone\UglyQueue $uglyQueue
-     */
-    public function testExceptionThrownWhenCallingIsLockedOnUninitializedQueue(\DCarbone\UglyQueue $uglyQueue)
-    {
-        $isLocked = $uglyQueue->isLocked();
-    }
-
-    /**
-     * @covers \DCarbone\UglyQueue::addToQueue
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanConstructUglyQueueWithValidParameter
-     * @expectedException \RuntimeException
-     * @param \DCarbone\UglyQueue $uglyQueue
-     */
-    public function testExceptionThrownWhenTryingToAddItemsToUninitializedQueue(\DCarbone\UglyQueue $uglyQueue)
-    {
-        $addToQueue = $uglyQueue->addToQueue('test', 'value');
-    }
-
-    /**
-     * @covers \DCarbone\UglyQueue::getQueueItemCount
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanConstructUglyQueueWithValidParameter
-     * @expectedException \RuntimeException
-     * @param \DCarbone\UglyQueue $uglyQueue
-     */
-    public function testExceptionThrownWhenTryingToGetCountOfItemsInQueueBeforeInitialization(\DCarbone\UglyQueue $uglyQueue)
-    {
-        $itemCount = $uglyQueue->getQueueItemCount();
-    }
-
-    /**
-     * @covers \DCarbone\UglyQueue::keyExistsInQueue
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanConstructUglyQueueWithValidParameter
-     * @expectedException \RuntimeException
-     * @param \DCarbone\UglyQueue $uglyQueue
-     */
-    public function testExceptionThrownWhenTryingToFindKeyBeforeInitialization(\DCarbone\UglyQueue $uglyQueue)
-    {
-        $keyExists = $uglyQueue->keyExistsInQueue(0);
-    }
-
-    /**
-     * @covers \DCarbone\UglyQueue::processQueue
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanConstructUglyQueueWithValidParameter
-     * @expectedException \RuntimeException
-     * @param \DCarbone\UglyQueue $uglyQueue
-     */
-    public function testExceptionThrownWhenTryingToProcessQueueBeforeInitialization(\DCarbone\UglyQueue $uglyQueue)
-    {
-        $process = $uglyQueue->processQueue();
-    }
-
-    /**
-     * @covers \DCarbone\UglyQueue::initialize
-     * @covers \DCarbone\UglyQueue::getInit
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanConstructUglyQueueWithValidParameter
-     * @param \DCarbone\UglyQueue $uglyQueue
-     * @return \DCarbone\UglyQueue
-     */
-    public function testCanInitializeNewUglyQueue(\DCarbone\UglyQueue $uglyQueue)
-    {
-        $uglyQueue->initialize('tasty-sandwich');
-
-        $this->assertTrue($uglyQueue->getInit());
-
-        return $uglyQueue;
-    }
-
-    /**
-     * @covers \DCarbone\UglyQueue::processQueue
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanInitializeNewUglyQueue
-     * @expectedException \RuntimeException
-     * @param \DCarbone\UglyQueue $uglyQueue
-     */
-    public function testExceptionThrownWhenTryingToProcessQueueAfterInitializationBeforeLock(\DCarbone\UglyQueue $uglyQueue)
-    {
-        $process = $uglyQueue->processQueue();
-    }
-
-    /**
-     * @covers \DCarbone\UglyQueue::keyExistsInQueue
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanInitializeNewUglyQueue
-     * @param \DCarbone\UglyQueue $uglyQueue
-     */
-    public function testKeyExistsInQueueReturnsFalseWithEmptyQueueAfterInitialization(\DCarbone\UglyQueue $uglyQueue)
+    public function testKeyExistsInQueueReturnsFalseWithEmptyQueueAfterInitialization(\Cybercinch\UglyQueue $uglyQueue)
     {
+        
         $exists = $uglyQueue->keyExistsInQueue(0);
 
         $this->assertFalse($exists);
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::addToQueue
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanInitializeNewUglyQueue
-     * @expectedException \RuntimeException
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @covers \Cybercinch\UglyQueue::addItem
+     * @uses \Cybercinch\UglyQueue
+     * @depends testCanInitializeObjectWithValidParameters
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testExceptionThrownWhenTryingToAddItemsToQueueWithoutLockAfterInitialization(\DCarbone\UglyQueue $uglyQueue)
+    public function testExceptionThrownWhenTryingToAddItemsToQueueWithoutLock(\Cybercinch\UglyQueue $uglyQueue)
     {
-        $addToQueue = $uglyQueue->addToQueue('test', 'value');
+        $this->expectException(\RuntimeException::class);
+        $uglyQueue->addItem('test', 'value');
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::getInit
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanInitializeNewUglyQueue
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @covers \Cybercinch\UglyQueue::getPath
+     * @uses \Cybercinch\UglyQueue
+     * @depends testCanInitializeObjectWithValidParameters
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testGetInitReturnsTrueAfterInitialization(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanGetQueueDirectory(\Cybercinch\UglyQueue $uglyQueue)
     {
-        $init = $uglyQueue->getInit();
-        $this->assertTrue($init);
+        $queuePath = $uglyQueue->getPath();
+
+        $this->assertFileExists($queuePath);
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::getQueueGroupDirPath
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanInitializeNewUglyQueue
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @covers \Cybercinch\UglyQueue::getName
+     * @uses \Cybercinch\UglyQueue
+     * @depends testCanInitializeObjectWithValidParameters
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testCanGetQueueGroupDirectoryAfterInitialization(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanGetQueueName(\Cybercinch\UglyQueue $uglyQueue)
     {
-        $queueGroupDir = $uglyQueue->getQueueGroupDirPath();
+        $queueName = $uglyQueue->getName();
 
-        $this->assertFileExists($queueGroupDir);
+        $this->assertEquals('tasty-sandwich', $queueName);
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::getQueueGroup
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanInitializeNewUglyQueue
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @covers \Cybercinch\UglyQueue::getMode
+     * @depends testCanInitializeObjectWithValidParameters
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testCanGetQueueGroupAfterInitialization(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanGetQueueMode(\Cybercinch\UglyQueue $uglyQueue)
     {
-        $queueGroup = $uglyQueue->getQueueGroup();
-
-        $this->assertEquals('tasty-sandwich', $queueGroup);
+        $mode = $uglyQueue->getMode();
+        $this->assertEquals(\Cybercinch\UglyQueue::QUEUE_READWRITE, $mode);
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::isLocked
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanInitializeNewUglyQueue
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @covers \Cybercinch\UglyQueue::getBaseDir
+     * @depends testCanInitializeObjectWithValidParameters
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testIsLockedReturnsFalseBeforeLockingAfterInitialization(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanGetBaseDirectory(\Cybercinch\UglyQueue $uglyQueue)
     {
-        $isLocked = $uglyQueue->isLocked();
-
-        $this->assertFalse($isLocked);
+        $baseDir = $uglyQueue->getBaseDir();
+        $this->assertEquals($this->baseDir, $baseDir);
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::getQueueItemCount
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanInitializeNewUglyQueue
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @covers \Cybercinch\UglyQueue::getLockFile
+     * @depends testCanInitializeObjectWithValidParameters
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testGetQueueItemCountReturnsZeroAfterInitializingEmptyQueue(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanGetLockFilePath(\Cybercinch\UglyQueue $uglyQueue)
     {
-        $itemCount = $uglyQueue->getQueueItemCount();
+        $lockFile = $uglyQueue->getLockFile();
+        $this->assertEquals(
+            sprintf('%s%s%s%squeue.lock',
+                $this->baseDir,
+                DIRECTORY_SEPARATOR,
+                $uglyQueue->getName(),
+                DIRECTORY_SEPARATOR),
+            $lockFile
+        );
+    }
+
+    /**
+     * @covers \Cybercinch\UglyQueue::getQueueFile
+     * @depends testCanInitializeObjectWithValidParameters
+     * @param \Cybercinch\UglyQueue $uglyQueue
+     */
+    public function testCanGetQueueFilePath(\Cybercinch\UglyQueue $uglyQueue)
+    {
+        $queueFile = $uglyQueue->getQueueFile();
+        $this->assertEquals(
+            sprintf('%s%s%s%squeue.txt',
+                $this->baseDir,
+                DIRECTORY_SEPARATOR,
+                $uglyQueue->getName(),
+                DIRECTORY_SEPARATOR),
+            $queueFile
+        );
+    }
+
+    /**
+     * @covers \Cybercinch\UglyQueue::getQueueTmpFile
+     * @depends testCanInitializeObjectWithValidParameters
+     * @param \Cybercinch\UglyQueue $uglyQueue
+     */
+    public function testCanGetQueueTmpFilePath(\Cybercinch\UglyQueue $uglyQueue)
+    {
+        $queueTmpFile = $uglyQueue->getQueueTmpFile();
+        $this->assertEquals(
+            sprintf(
+                '%s%s%s%squeue.tmp',
+                $this->baseDir,
+                DIRECTORY_SEPARATOR,
+                $uglyQueue->getName(),
+                DIRECTORY_SEPARATOR),
+            $queueTmpFile
+        );
+    }
+
+    /**
+     * @covers \Cybercinch\UglyQueue::getSerializeFile
+     * @depends testCanInitializeObjectWithValidParameters
+     * @param \Cybercinch\UglyQueue $uglyQueue
+     */
+    public function testCanGetSerializeFilePath(\Cybercinch\UglyQueue $uglyQueue)
+    {
+        $serializeFile = $uglyQueue->getSerializeFile();
+        $this->assertEquals(
+            sprintf(
+                '%s%s%s%sugly-queue.obj',
+                $this->baseDir,
+                DIRECTORY_SEPARATOR,
+                $uglyQueue->getName(),
+                DIRECTORY_SEPARATOR),
+            $serializeFile
+        );
+    }
+
+    /**
+     * @covers \Cybercinch\isAlreadyLocked::isAlreadyLocked
+     * @uses \Cybercinch\UglyQueue
+     * @depends testCanInitializeObjectWithValidParameters
+     * @param \Cybercinch\UglyQueue $uglyQueue
+     */
+    public function testCanGetQueueLockedStatus(\Cybercinch\UglyQueue $uglyQueue)
+    {
+        $locked = $uglyQueue->isAlreadyLocked();
+        $this->assertFalse($locked);
+    }
+
+    /**
+     * @covers \Cybercinch\UglyQueue::count
+     * @uses \Cybercinch\UglyQueue
+     * @depends testCanInitializeObjectWithValidParameters
+     * @param \Cybercinch\UglyQueue $uglyQueue
+     */
+    public function testGetQueueItemCountReturnsZeroWithEmptyQueue(\Cybercinch\UglyQueue $uglyQueue)
+    {
+        $itemCount = count($uglyQueue);
         $this->assertEquals(0, $itemCount);
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::initialize
-     * @covers \DCarbone\UglyQueue::__construct
-     * @covers \DCarbone\UglyQueue::getInit
-     * @uses \DCarbone\UglyQueue
-     * @return \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::__construct
+     * @uses \Cybercinch\UglyQueue
+     * @return \Cybercinch\UglyQueue
      */
     public function testCanInitializeExistingQueue()
     {
-        $conf = array(
-            'queue-base-dir' => dirname(__DIR__).'/misc/',
-        );
+        $uglyQueue = new \Cybercinch\UglyQueue($this->baseDir, 'tasty-sandwich');
 
-        $uglyQueue = new \DCarbone\UglyQueue($conf);
-
-        $this->assertInstanceOf('\\DCarbone\\UglyQueue', $uglyQueue);
-
-        $this->assertFalse($uglyQueue->getInit());
-
-        $uglyQueue->initialize('tasty-sandwich');
-
-        $this->assertTrue($uglyQueue->getInit());
+        $this->assertInstanceOf('\\Cybercinch\\UglyQueue', $uglyQueue);
 
         return $uglyQueue;
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::lock
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanConstructUglyQueueWithValidParameter
-     * @expectedException \InvalidArgumentException
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @covers \Cybercinch\UglyQueue::lock
+     * @uses \Cybercinch\UglyQueue
+     * @depends testCanInitializeObjectWithValidParameters
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testExceptionThrownWhenPassingNonIntegerValueToLock(\DCarbone\UglyQueue $uglyQueue)
+    public function testExceptionThrownWhenPassingNonIntegerValueToLock(\Cybercinch\UglyQueue $uglyQueue)
     {
+        $this->expectException(\InvalidArgumentException::class);
         $uglyQueue->lock('7 billion');
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::lock
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanConstructUglyQueueWithValidParameter
-     * @expectedException \InvalidArgumentException
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @covers \Cybercinch\UglyQueue::lock
+     * @uses \Cybercinch\UglyQueue
+     * @depends testCanInitializeObjectWithValidParameters
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testExceptionThrownWhenPassingNegativeIntegerValueToLock(\DCarbone\UglyQueue $uglyQueue)
+    public function testExceptionThrownWhenPassingNegativeIntegerValueToLock(\Cybercinch\UglyQueue $uglyQueue)
     {
+        $this->expectException(\InvalidArgumentException::class);
         $uglyQueue->lock(-73);
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::lock
-     * @covers \DCarbone\UglyQueue::isLocked
-     * @covers \DCarbone\UglyQueue::createQueueLock
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanInitializeNewUglyQueue
-     * @param \DCarbone\UglyQueue $uglyQueue
-     * @return \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::lock
+     * @covers \Cybercinch\isAlreadyLocked::isAlreadyLocked
+     * @covers \Cybercinch\UglyQueue::createLockFile
+     * @uses \Cybercinch\UglyQueue
+     * @depends testCanInitializeObjectWithValidParameters
+     * @param \Cybercinch\UglyQueue $uglyQueue
+     * @return \Cybercinch\UglyQueue
      */
-    public function testCanLockUglyQueueWithDefaultTTL(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanLockUglyQueueWithDefaultTTL(\Cybercinch\UglyQueue $uglyQueue)
     {
         $locked = $uglyQueue->lock();
 
         $this->assertTrue($locked);
 
-        $queueDir = $uglyQueue->getQueueBaseDir().$uglyQueue->getQueueGroup().'/';
+        $this->assertFileExists($uglyQueue->getLockFile());
 
-        $this->assertFileExists($queueDir.'queue.lock');
-
-        $decode = @json_decode(file_get_contents($queueDir.'queue.lock'));
+        $decode = @json_decode(file_get_contents($uglyQueue->getLockFile()));
 
         $this->assertTrue((json_last_error() === JSON_ERROR_NONE));
         $this->assertObjectHasAttribute('ttl', $decode);
@@ -379,103 +297,104 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::lock
-     * @covers \DCarbone\UglyQueue::isLocked
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::lock
+     * @covers \Cybercinch\isAlreadyLocked::isAlreadyLocked
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanInitializeExistingQueue
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testCannotLockInitializedQueueThatIsAlreadyLocked(\DCarbone\UglyQueue $uglyQueue)
+    public function testCannotLockQueueThatIsAlreadyLocked(\Cybercinch\UglyQueue $uglyQueue)
     {
+        
         $lock = $uglyQueue->lock();
 
         $this->assertFalse($lock);
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::isLocked
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\isAlreadyLocked::isAlreadyLocked
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanLockUglyQueueWithDefaultTTL
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testIsLockedReturnsTrueAfterLockingInitializedQueue(\DCarbone\UglyQueue $uglyQueue)
+    public function testIsLockedReturnsTrueAfterLocking(\Cybercinch\UglyQueue $uglyQueue)
     {
-        $isLocked = $uglyQueue->isLocked();
+        
+        $isLocked = $uglyQueue->isAlreadyLocked();
         $this->assertTrue($isLocked);
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::unlock
-     * @uses \DCarbone\UglyQueue
-     * @uses \DCarbone\Helpers\FileHelper
+     * @covers \Cybercinch\UglyQueue::unlock
+     * @uses \Cybercinch\UglyQueue
+     * @uses \Cybercinch\Helpers\FileHelper
      * @depends testCanLockUglyQueueWithDefaultTTL
-     * @param \DCarbone\UglyQueue $uglyQueue
-     * @return \DCarbone\UglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
+     * @return \Cybercinch\UglyQueue
      */
-    public function testCanUnlockLockedQueue(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanUnlockLockedQueue(\Cybercinch\UglyQueue $uglyQueue)
     {
+        
         $uglyQueue->unlock();
 
-        $queueGroupDir = $uglyQueue->getQueueGroupDirPath();
-
-        $this->assertFileNotExists($queueGroupDir.'queue.lock');
+        $this->assertFileNotExists($uglyQueue->getLockFile());
 
         return $uglyQueue;
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::isLocked
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\isAlreadyLocked::isAlreadyLocked
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanUnlockLockedQueue
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testIsLockedReturnsFalseAfterUnlockingQueue(\DCarbone\UglyQueue $uglyQueue)
+    public function testIsLockedReturnsFalseAfterUnlockingQueue(\Cybercinch\UglyQueue $uglyQueue)
     {
-        $isLocked = $uglyQueue->isLocked();
+        
+        $isLocked = $uglyQueue->isAlreadyLocked();
 
         $this->assertFalse($isLocked);
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::lock
-     * @covers \DCarbone\UglyQueue::isLocked
-     * @uses \DCarbone\UglyQueue
-     * @uses \DCarbone\Helpers\FileHelper
+     * @covers \Cybercinch\UglyQueue::lock
+     * @covers \Cybercinch\isAlreadyLocked::isAlreadyLocked
+     * @uses \Cybercinch\UglyQueue
+     * @uses \Cybercinch\Helpers\FileHelper
      * @depends testCanUnlockLockedQueue
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testIsLockedReturnsFalseWithStaleQueueLockFile(\DCarbone\UglyQueue $uglyQueue)
+    public function testIsLockedReturnsFalseWithStaleQueueLockFile(\Cybercinch\UglyQueue $uglyQueue)
     {
+        
         $uglyQueue->lock(2);
-        $isLocked = $uglyQueue->isLocked();
+        $isLocked = $uglyQueue->isAlreadyLocked();
         $this->assertTrue($isLocked);
 
         sleep(3);
 
-        $isLocked = $uglyQueue->isLocked();
+        $isLocked = $uglyQueue->isAlreadyLocked();
         $this->assertFalse($isLocked);
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::lock
-     * @covers \DCarbone\UglyQueue::isLocked
-     * @covers \DCarbone\UglyQueue::getQueueGroupDirPath
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::lock
+     * @covers \Cybercinch\isAlreadyLocked::isAlreadyLocked
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanUnlockLockedQueue
-     * @param \DCarbone\UglyQueue $uglyQueue
-     * @return \DCarbone\UglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
+     * @return \Cybercinch\UglyQueue
      */
-    public function testCanLockQueueWithValidIntegerValue(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanLockQueueWithValidIntegerValue(\Cybercinch\UglyQueue $uglyQueue)
     {
+        
         $locked = $uglyQueue->lock(200);
 
         $this->assertTrue($locked);
 
-        $queueDir = $uglyQueue->getQueueGroupDirPath();
+        $this->assertFileExists($uglyQueue->getLockFile());
 
-        $this->assertFileExists($queueDir.'queue.lock');
-
-        $decode = @json_decode(file_get_contents($queueDir.'queue.lock'));
+        $decode = @json_decode(file_get_contents($uglyQueue->getLockFile()));
 
         $this->assertTrue((json_last_error() === JSON_ERROR_NONE));
         $this->assertObjectHasAttribute('ttl', $decode);
@@ -486,28 +405,27 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::addToQueue
-     * @uses \DCarbone\UglyQueue
-     * @uses \DCarbone\Helpers\FileHelper
+     * @covers \Cybercinch\UglyQueue::addItem
+     * @uses \Cybercinch\UglyQueue
+     * @uses \Cybercinch\Helpers\FileHelper
      * @depends testCanLockQueueWithValidIntegerValue
-     * @param \DCarbone\UglyQueue $uglyQueue
-     * @return \DCarbone\UglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
+     * @return \Cybercinch\UglyQueue
      */
-    public function testCanPopulateQueueTempFileAfterInitializationAndAcquiringLock(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanPopulateQueueTempFileAfterInitializationAndAcquiringLock(\Cybercinch\UglyQueue $uglyQueue)
     {
+        
         foreach(array_reverse($this->tastySandwich, true) as $k=>$v)
         {
-            $added = $uglyQueue->addToQueue($k, $v);
+            $added = $uglyQueue->addItem($k, $v);
             $this->assertTrue($added);
         }
 
-        $groupDir = $uglyQueue->getQueueGroupDirPath();
-
         $this->assertFileExists(
-            $groupDir.'queue.tmp',
+            $uglyQueue->getQueueTmpFile(),
             'queue.tmp file was not created!');
 
-        $lineCount = \DCarbone\Helpers\FileHelper::getLineCount($groupDir.'queue.tmp');
+        $lineCount = \Dcarbone\Helpers\FileHelper::getLineCount($uglyQueue->getQueueTmpFile());
 
         $this->assertEquals(11, $lineCount);
 
@@ -515,19 +433,18 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::_populateQueue
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::_populateQueue
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanPopulateQueueTempFileAfterInitializationAndAcquiringLock
-     * @param \DCarbone\UglyQueue $uglyQueue
-     * @return \DCarbone\UglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
+     * @return \Cybercinch\UglyQueue
      */
-    public function testCanForciblyUpdateQueueFileFromTempFile(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanForciblyUpdateQueueFileFromTempFile(\Cybercinch\UglyQueue $uglyQueue)
     {
+        
         $uglyQueue->_populateQueue();
 
-        $groupDir = $uglyQueue->getQueueGroupDirPath();
-
-        $this->assertFileNotExists($groupDir.'queue.tmp');
+        $this->assertFileNotExists($uglyQueue->getQueueTmpFile());
 
         $uglyQueue->_populateQueue();
 
@@ -535,139 +452,102 @@ class UglyQueueTest extends PHPUnit_Framework_TestCase
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::getQueueItemCount
-     * @uses \DCarbone\UglyQueue
-     * @uses \DCarbone\Helpers\FileHelper
+     * @covers \Cybercinch\UglyQueue::count
+     * @uses \Cybercinch\UglyQueue
+     * @uses \Cybercinch\Helpers\FileHelper
      * @depends testCanPopulateQueueTempFileAfterInitializationAndAcquiringLock
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testCanGetCountOfItemsInPopulatedQueue(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanGetCountOfItemsInPopulatedQueue(\Cybercinch\UglyQueue $uglyQueue)
     {
-        $itemCount = $uglyQueue->getQueueItemCount();
+        $itemCount = count($uglyQueue);
 
         $this->assertEquals(11, $itemCount);
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::keyExistsInQueue
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::keyExistsInQueue
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanPopulateQueueTempFileAfterInitializationAndAcquiringLock
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testKeyExistsReturnsTrueWithPopulatedQueue(\DCarbone\UglyQueue $uglyQueue)
+    public function testKeyExistsReturnsTrueWithPopulatedQueue(\Cybercinch\UglyQueue $uglyQueue)
     {
+        
         $exists = $uglyQueue->keyExistsInQueue(5);
 
         $this->assertTrue($exists);
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::processQueue
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::retrieveItems
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanPopulateQueueTempFileAfterInitializationAndAcquiringLock
-     * @expectedException \InvalidArgumentException
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testExceptionThrownWhenTryingToProcessLockedQueueWithNonInteger(\DCarbone\UglyQueue $uglyQueue)
+    public function testExceptionThrownWhenTryingToProcessLockedQueueWithNonInteger(\Cybercinch\UglyQueue $uglyQueue)
     {
-        $process = $uglyQueue->processQueue('Eleventy Billion');
+        $this->expectException(\InvalidArgumentException::class);
+        $uglyQueue->retrieveItems('Eleventy Billion');
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::processQueue
-     * @uses \DCarbone\UglyQueue
+     * @covers \Cybercinch\UglyQueue::retrieveItems
+     * @uses \Cybercinch\UglyQueue
      * @depends testCanPopulateQueueTempFileAfterInitializationAndAcquiringLock
-     * @expectedException \InvalidArgumentException
-     * @param \DCarbone\UglyQueue $uglyQueue
+     * @expectedException
+     * @param \Cybercinch\UglyQueue $uglyQueue
      */
-    public function testExceptionThrownWhenTryingToProcessLockedQueueWithIntegerLessThan1(\DCarbone\UglyQueue $uglyQueue)
+    public function testExceptionThrownWhenTryingToProcessLockedQueueWithIntegerLessThan1(\Cybercinch\UglyQueue $uglyQueue)
     {
-        $process = $uglyQueue->processQueue(0);
+        $this->expectException(\InvalidArgumentException::class);
+        $uglyQueue->retrieveItems(0);
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::processQueue
-     * @covers \DCarbone\UglyQueue::getQueueItemCount
-     * @uses \DCarbone\UglyQueue
-     * @uses \DCarbone\Helpers\FileHelper
+     * @covers \Cybercinch\UglyQueue::retrieveItems
+     * @covers \Cybercinch\UglyQueue::count
+     * @uses \Cybercinch\UglyQueue
+     * @uses \Cybercinch\Helpers\FileHelper
      * @depends testCanPopulateQueueTempFileAfterInitializationAndAcquiringLock
-     * @param \DCarbone\UglyQueue $uglyQueue
-     * @return \DCarbone\UglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
+     * @return \Cybercinch\UglyQueue
      */
-    public function testCanGetPartialQueueContents(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanGetPartialQueueContents(\Cybercinch\UglyQueue $uglyQueue)
     {
-        $process = $uglyQueue->processQueue(5);
+        
+        $process = $uglyQueue->retrieveItems(5);
 
         $this->assertEquals(5, count($process));
 
         $this->assertArrayHasKey('0', $process);
         $this->assertArrayHasKey('4', $process);
 
-        $this->assertEquals(6, $uglyQueue->getQueueItemCount());
+        $this->assertEquals(6, count($uglyQueue));
 
         return $uglyQueue;
     }
 
     /**
-     * @covers \DCarbone\UglyQueue::processQueue
-     * @covers \DCarbone\UglyQueue::getQueueItemCount
-     * @uses \DCarbone\UglyQueue
-     * @uses \DCarbone\Helpers\FileHelper
+     * @covers \Cybercinch\UglyQueue::retrieveItems
+     * @covers \Cybercinch\UglyQueue::count
+     * @uses \Cybercinch\UglyQueue
+     * @uses \Cybercinch\Helpers\FileHelper
      * @depends testCanGetPartialQueueContents
-     * @param \DCarbone\UglyQueue $uglyQueue
-     * @return \DCarbone\UglyQueue
+     * @param \Cybercinch\UglyQueue $uglyQueue
+     * @return \Cybercinch\UglyQueue
      */
-    public function testCanGetFullQueueContents(\DCarbone\UglyQueue $uglyQueue)
+    public function testCanGetFullQueueContents(\Cybercinch\UglyQueue $uglyQueue)
     {
-        $process = $uglyQueue->processQueue(6);
+        $process = $uglyQueue->retrieveItems(6);
 
         $this->assertEquals(6, count($process));
 
         $this->assertArrayHasKey('10', $process);
         $this->assertArrayHasKey('5', $process);
 
-        $this->assertEquals(0, $uglyQueue->getQueueItemCount());
+        $this->assertEquals(0, count($uglyQueue));
 
         return $uglyQueue;
     }
-
-    /**
-     * @covers \DCarbone\UglyQueue::queueExists
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanInitializeNewUglyQueue
-     * @param \DCarbone\UglyQueue $uglyQueue
-     */
-    public function testCanDetermineExistenceOfExistingQueue(\DCarbone\UglyQueue $uglyQueue)
-    {
-        $exists = $uglyQueue->queueExists('tasty-sandwich');
-
-        $this->assertTrue($exists);
-    }
-
-    /**
-     * @covers \DCarbone\UglyQueue::queueExists
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanInitializeNewUglyQueue
-     * @param \DCarbone\UglyQueue $uglyQueue
-     */
-    public function testCanDetermineExistenceOfNonExistingQueue(\DCarbone\UglyQueue $uglyQueue)
-    {
-        $exists = $uglyQueue->queueExists('nasty-sandwich');
-
-        $this->assertFalse($exists);
-    }
-
-    /**
-     * @covers \DCarbone\UglyQueue::getInitializedQueueList
-     * @uses \DCarbone\UglyQueue
-     * @depends testCanInitializeNewUglyQueue
-     * @param \DCarbone\UglyQueue $uglyQueue
-     */
-    public function testCanGetListOfInitializedQueues(\DCarbone\UglyQueue $uglyQueue)
-    {
-        $queueList = $uglyQueue->getInitializedQueueList();
-
-        $this->assertEquals(1, count($queueList));
-        $this->assertContains('tasty-sandwich', $queueList);
-    }
 }

tests/UglyQueueManager/UglyQueueManagerTest.php

@@ -0,0 +1,214 @@
+<?php
+
+/**
+ * Class UglyQueueManagerTest
+ */
+class UglyQueueManagerTest extends PHPUnit\Framework\TestCase
+{
+    protected $baseDir;
+
+    protected $reallyTastySandwich = array(
+        '0' => 'beef broth',
+        '1' => 'barbeque sauce',
+        '2' => 'boneless pork ribs',
+    );
+
+    protected function setUp(): void
+    {
+        $this->baseDir = realpath(__DIR__.'/../misc/queues');
+    }
+
+    /**
+     * @covers \Cybercinch\UglyQueueManager::__construct
+     * @covers \Cybercinch\UglyQueue::unserialize
+     * @covers \Cybercinch\UglyQueueManager::addQueue
+     * @covers \Cybercinch\UglyQueueManager::containsQueueWithName
+     * @uses \Cybercinch\UglyQueueManager
+     * @uses \Cybercinch\UglyQueue
+     * @return \Cybercinch\UglyQueueManager
+     */
+    public function testCanInitializeObjectWithValidPath()
+    {
+        $manager = new \Cybercinch\UglyQueueManager($this->baseDir);
+
+        $this->assertInstanceOf('\\Cybercinch\\UglyQueueManager', $manager);
+
+        return $manager;
+    }
+
+    /**
+     * @covers \Cybercinch\UglyQueueManager::__construct
+     * @uses \Cybercinch\UglyQueueManager
+     */
+    public function testExceptionThrownDuringConstructionWithInvalidBasePathValue()
+    {
+        $this->expectException(RuntimeException::class);
+        new \Cybercinch\UglyQueueManager('i do not exist!');
+    }
+
+
+    /**
+     * @covers \Cybercinch\UglyQueueManager::containsQueueWithName
+     * @uses \Cybercinch\UglyQueueManager
+     * @depends testCanInitializeObjectWithValidPath
+     * @param \Cybercinch\UglyQueueManager $manager
+     */
+    public function testCanDetermineIfValidQueueExistsInManager(\Cybercinch\UglyQueueManager $manager)
+    {
+        $shouldBeTrue = $manager->containsQueueWithName('tasty-sandwich');
+
+        $this->assertTrue($shouldBeTrue);
+    }
+
+    /**
+     * @covers \Cybercinch\UglyQueueManager::containsQueueWithName
+     * @uses \Cybercinch\UglyQueueManager
+     * @depends testCanInitializeObjectWithValidPath
+     * @param \Cybercinch\UglyQueueManager $manager
+     */
+    public function testCanDetermineQueueDoesNotExistInManager(\Cybercinch\UglyQueueManager $manager)
+    {
+        $shouldBeFalse = $manager->containsQueueWithName('i should not exist');
+
+        $this->assertFalse($shouldBeFalse);
+    }
+
+    /**
+     * @covers \Cybercinch\UglyQueueManager::getQueueWithName
+     * @uses \Cybercinch\UglyQueueManager
+     * @uses \Cybercinch\UglyQueue
+     * @depends testCanInitializeObjectWithValidPath
+     * @param \Cybercinch\UglyQueueManager $manager
+     */
+    public function testCanGetUglyQueueObjectFromManager(\Cybercinch\UglyQueueManager $manager)
+    {
+        $uglyQueue = $manager->getQueueWithName('tasty-sandwich');
+
+        $this->assertInstanceOf('\\Cybercinch\\UglyQueue', $uglyQueue);
+        $this->assertEquals('tasty-sandwich', $uglyQueue->getName());
+    }
+
+    /**
+     * @covers \Cybercinch\UglyQueueManager::getQueueWithName
+     * @uses \Cybercinch\UglyQueueManager
+     * @depends testCanInitializeObjectWithValidPath
+     * @param \Cybercinch\UglyQueueManager $manager
+     */
+    public function testExceptionThrownWhenTryingToGetNonExistentQueueFromManager(\Cybercinch\UglyQueueManager $manager)
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $manager->getQueueWithName('sandwiches');
+    }
+
+    /**
+     * @covers \Cybercinch\UglyQueueManager::getQueueList
+     * @uses \Cybercinch\UglyQueueManager
+     * @depends testCanInitializeObjectWithValidPath
+     * @param \Cybercinch\UglyQueueManager $manager
+     */
+    public function testCanGetListOfQueuesInManager(\Cybercinch\UglyQueueManager $manager)
+    {
+        $queueList = $manager->getQueueList();
+
+        $this->assertIsArray($queueList);
+        $this->assertCount(1, $queueList);
+        $this->assertContains('tasty-sandwich', $queueList);
+    }
+
+    /**
+     * @covers \Cybercinch\UglyQueueManager::getQueueWithName
+     * @covers \Cybercinch\UglyQueueManager::addQueue
+     * @uses \Cybercinch\UglyQueueManager
+     * @uses \Cybercinch\UglyQueue
+     * @depends testCanInitializeObjectWithValidPath
+     * @param \Cybercinch\UglyQueueManager $manager
+     */
+    public function testExceptionThrownWhenReAddingQueueToManager(\Cybercinch\UglyQueueManager $manager)
+    {
+        $this->expectException(RuntimeException::class);
+        $uglyQueue = $manager->getQueueWithName('tasty-sandwich');
+
+        $manager->addQueue($uglyQueue);
+    }
+
+    /**
+     * @covers \Cybercinch\UglyQueueManager::addQueueAtPath
+     * @covers \Cybercinch\UglyQueueManager::addQueue
+     * @covers \Cybercinch\UglyQueueManager::getQueueWithName
+     * @uses \Cybercinch\UglyQueueManager
+     * @uses \Cybercinch\UglyQueue
+     * @depends testCanInitializeObjectWithValidPath
+     * @param \Cybercinch\UglyQueueManager $manager
+     */
+    public function testCanInitializeNewQueueAndAddToManager(\Cybercinch\UglyQueueManager $manager)
+    {
+        $manager->addQueueAtPath($this->baseDir.'/really-tasty-sandwich');
+
+        $uglyQueue = $manager->getQueueWithName('really-tasty-sandwich');
+
+        $this->assertInstanceOf('\\Cybercinch\\UglyQueue', $uglyQueue);
+        $this->assertEquals('really-tasty-sandwich', $uglyQueue->getName());
+
+        $queueList = $manager->getQueueList();
+
+        $this->assertIsArray($queueList);
+        $this->assertCount(2, $queueList);
+        $this->assertContains('really-tasty-sandwich', $queueList);
+    }
+
+    /**
+     * @covers \Cybercinch\UglyQueueManager::removeQueueByName
+     * @uses \Cybercinch\UglyQueueManager
+     * @depends testCanInitializeObjectWithValidPath
+     * @param \Cybercinch\UglyQueueManager $manager
+     */
+    public function testCanRemoveQueueFromManagerByName(\Cybercinch\UglyQueueManager $manager)
+    {
+        $manager->removeQueueByName('really-tasty-sandwich');
+
+        $queueList = $manager->getQueueList();
+
+        $this->assertCount(1, $queueList);
+        $this->assertNotContains('really-tasty-sandwich', $queueList);
+    }
+
+//    /**
+//     * @covers \Cybercinch\UglyQueue::queueExists
+//     * @uses \Cybercinch\UglyQueue
+//     * @depends testCanInitializeNewUglyQueue
+//     * @param \Cybercinch\UglyQueue $uglyQueue
+//     */
+//    public function testCanDetermineExistenceOfExistingQueue(\Cybercinch\UglyQueue $uglyQueue)
+//    {
+//        $exists = $uglyQueue->queueExists('tasty-sandwich');
+//
+//        $this->assertTrue($exists);
+//    }
+//
+//    /**
+//     * @covers \Cybercinch\UglyQueue::queueExists
+//     * @uses \Cybercinch\UglyQueue
+//     * @depends testCanInitializeNewUglyQueue
+//     * @param \Cybercinch\UglyQueue $uglyQueue
+//     */
+//    public function testCanDetermineExistenceOfNonExistingQueue(\Cybercinch\UglyQueue $uglyQueue)
+//    {
+//        $exists = $uglyQueue->queueExists('nasty-sandwich');
+//
+//        $this->assertFalse($exists);
+//    }
+//
+//    /**
+//     * @covers \Cybercinch\UglyQueue::getInitializedQueueList
+//     * @uses \Cybercinch\UglyQueue
+//     * @depends testCanInitializeNewUglyQueue
+//     * @param \Cybercinch\UglyQueue $uglyQueue
+//     */
+//    public function testCanGetListOfInitializedQueues(\Cybercinch\UglyQueue $uglyQueue)
+//    {
+//        $queueList = $uglyQueue->getInitializedQueueList();
+//
+//        $this->assertEquals(1, count($queueList));
+//        $this->assertContains('tasty-sandwich', $queueList);
+//    }
+}

tests/misc/cleanup.php

@@ -1,13 +1,22 @@
 <?php
 
-if (is_dir(__DIR__.'/tasty-sandwich'))
+if (is_dir(__DIR__.'/queues/'))
 {
-    foreach(glob(__DIR__.'/tasty-sandwich/*') as $file)
+    foreach(glob(__DIR__.'/queues/*', GLOB_ONLYDIR) as $queueDir)
     {
-        if (substr($file, -1) === '.')
-            continue;
+        foreach(glob($queueDir.'/*') as $file)
+        {
+            $split = preg_split('#[/\\\]+#', $file);
+            if (strpos(end($split), '.') === 0)
+                continue;
 
-        unlink($file);
+            unlink($file);
+        }
+
+        rmdir($queueDir);
     }
-    rmdir(__DIR__.'/tasty-sandwich');
+}
+else
+{
+    mkdir(__DIR__.'/queues');
 }