Lately I've been finding myself experimenting with Wordpress. I created a <a href="https://github.com/levijackson/docker-wordpress" target="_blank">docker-compose file</a> to help me stand up a new clean setup more quickly.

It is based upon the <a href="https://docs.docker.com/compose/wordpress/" target="_blank">Docker compose guide</a>, but includes some extras, like phpMyAdmin.

## Usage
1) Clone the repository or copy the docker-compose file
2) Start the container `docker-compose up -d`
3) Run through the Wordpress installer http://localhost:8000

## Adding a theme or plugin
The `wp-content/` directory is mounted to the local file system. It makes it easy to copy plugins, or edit the theme files from your IDE.

## phpMyAdmin
You can access phpMyAdmin from http://localhost:8080 using the credentials set in the `docker-compose.yml` file (`MYSQL_USER` and `MYSQL_PASSWORD`).

## Reset the database
If you find you need to reset the data, you can delete the volumes created.
```
docker-compose down --volumes
```

Develop Wordpress using Docker

The <a href="https://docs.aws.amazon.com/cli/latest/userguide/install-macos.html" target="_blank" rel="noopener noreferrer">AWS guide</a> is still a good starting point for this. The main piece I had trouble with was using `aws --version` once it was installed.

*Prerequisite:* have Python3 and Pip3 installed

## Quick answer:
Adjust $PATH so it has the path to the AWS executable.


## Longer answer:
### 1) Find where it installed AWS

The guide says to use `which python3` - but when I installed Python it installed it to my user, not the system. 

When you run `pip3 install awscli --updgrade --user` it should spit out something like this
```
... awscli in ./Library/Python/3.8/lib/python/site-packages (1.18.18)
```
The **"./"** indicated it is a local path, NOT the system path. You can confirm by checking 
```
ls -la /Users/<insert_user_name>/Library/Python/3.8/bin/aws
```

### 2) Edit `~./bash_profile` and add the path
```
export PATH=/Users/<insert_user_name>/Library/Python/3.8/bin:$PATH
```

### 3) Reload the profile
```
source .bash_profile
```
### 4) Test - `aws --version`. It should output
```
aws-cli/1.18.18 Python/3.8.2 Darwin/17.7.0 botocore/1.15.18
```

Installing AWS CLI on Mac

Setting up composer to use a private repo is pretty easy... after you've done it once. There are a few things that can trip you up, such as the naming of the package and the version to include. The <a href="https://getcomposer.org/doc/05-repositories.md#using-private-repositories" target="_blank" rel="noopener noreferrer">docs</a> for getting the configuration set up got me about 95% of the way there.

This guide assumes you already have a *composer.json* file created, and you're looking to add a new private repository to that.


## Part 1: Bitbucket configuration
Composer is going to need access to your Bitbucket account in order to fetch the private git repo. An OAuth consumer can be used to give composer access.
1) In Bitbucket, go to your "Bitbucket Settings" page `https://bitbucket.org/account/user/<username>/`

2) Click "OAuth"

![Click OAuth](/images/posts/using-a-private-repo-with-composer-and-bitbucket/oauth_link.png)

3) Click the "Add consumer" button

![Click the "Add consumer" button](/images/posts/using-a-private-repo-with-composer-and-bitbucket/consumer_button.png)


4) Fill in the name, description, callback URL (this can be anything - composer won't use it but it is required by Bitbucket), select This is a private consumer, and select Repositories: Read for the permissions.

![Consumer config part 1](/images/posts/using-a-private-repo-with-composer-and-bitbucket/consumer_config_pt1.png)

![Consumer config part 2](/images/posts/using-a-private-repo-with-composer-and-bitbucket/consumer_config_pt2.png)


## Part 2: Composer configuration
Using the *Key* and *Secret* from the OAuth consumer you created in part 1, you will need to add an *auth.json* file in composer's home directory.
```
vi ~/.composer/auth.json
```
```
{
 "bitbucket-oauth": {
 "bitbucket.org": {
 "consumer-key": "myKey",
 "consumer-secret": "mySecret"
 }
 }
}
```

## Part 3: Configure composer.json
1) Add your private repository to the configuration so composer can look there for packages. The URL for the repo can be found in Bitbucket by clicking the "Clone" button in the top right of the repository view.

![Package URL](/images/posts/using-a-private-repo-with-composer-and-bitbucket/package_url.png)

```
"repositories": [
 {
 "type": "git",
 "url": "https://aerosox@bitbucket.org/aerosox/dataconverter.git"
 }
]
```

2) Require the package in *composer.json*. With either of these methods.
- CLI: `composer require aerosox/dataconverter`
- Edit `composer.json`

```
"require": {
 "aerosox/dataconverter": "master@dev"
 }
```

## Troubleshooting
1) the package name in the *require* matches the name from the `composer.json` configuration for the package you are including.

```
// composer.json from aerosox/dataconvert

{
 // even though the git repo is configured as aerosox/dataconverter.git, this name *could* be anything. This is what composer is going to be looking for when it searches for the package to install.
 "name": "aerosox/dataconverter",
 "description": "Convert data formats",
 "type": "library",
 "authors": [
 {
 "name": "Levi Jackson",
 "email": "aerosox@gmail.com"
 }
 ],
 "autoload": {
 "psr-4": {
 "DataConverter\\": "src/"
 }
 },
 "require-dev": {
 "phpunit/phpunit": "^6.5"
 }
}
```
2) I saw a lot of guides say to load the package as `"aerosox/dataconverter": "master-dev"`. I initially thought that *master-dev* was a composer standard, but it's not. If you want to use that, you'd want to set up an alias in the package so it can be found.

```
"extra": {
 "branch-alias": {
 "master-dev": "actual-branch-name"
 }
}
```

Using a private repo with composer and bitbucket

I was discussing the speed of filtering an array with a colleague and I had been under the assumption that using PHP *array_*\* functions are considerably faster than using a loop (foreach, for, while) . I could not find evidence of that when I was doing some Google searches though so I decided to do a little bit of a speed test on my own.

For all of these tests I set up the following beforehand:

```
ini_set('memory_limit', '500M');
$data = range(0, 1000000);
```

## Test 1: array_filter vs loops
| Type | Time |
| ---- | ---- |
| foreach | 0.37 |
| while | 0.58 |
| for | 0.61 |
| array_filter | 0.74 |


```
// array_filter loop average 0.74 seconds
$start = microtime(true);
$data = array_filter($data, function ($item) {
 return $item%2;
});
$end = microtime(true);

echo $end - $start;

// Foreach loop average 0.37 seconds
$start = microtime(true);
$newData = array();
foreach ($data as $item) {
 if ($item%2) {
 $newData[] = $item;
 }
}
$end = microtime(true);

echo $end - $start;

// For loop average 0.61 seconds
$start = microtime(true);
$newData = array();
$numItems = count($data);
for($i=0;$i<=$numItems;$i++) {
 if ($data[$i]%2) {
 $newData[] = $data[$i];
 }
}
$end = microtime(true);

echo $end - $start;

// While loop average 0.58 seconds
$start = microtime(true);
$newData = array();
$numItems = count($data);
$i = 0;
while ($i <= $numItems) {
 if ($data[$i]%2) {
 $newData[] = $data[$i];
 }
 $i++;
}
$end = microtime(true);

echo $end - $start;
```


## Test 2: array_map vs loops
| Type | Time |
| ---- | ---- |
| foreach | 0.65 |
| while | 0.69 |
| for | 0.76 |
| array_filter | 1.38 |

```
// array_map average 1.38 seconds
$start = microtime(true);
$data = array_map(function ($item) {
 return $item+1;
}, $data);
$end = microtime(true);

echo $end - $start;

// For loop average 0.65 seconds
$start = microtime(true);
$newData = array();
foreach ($data as $item) {
 $newData[] = $item+1;
}
$end = microtime(true);

echo $end - $start;

// For loop average 0.76 seconds
$start = microtime(true);
$newData = array();
$numItems = count($data);
for($i=0;$i<=$numItems;$i++) {
 $newData[] = $data[$i]+1;
}
$end = microtime(true);

echo $end - $start;

// While loop average 0.69 seconds
$start = microtime(true);
$newData = array();
$numItems = count($data);
$i = 0;
while ($i <= $numItems) {
 $newData[] = $data[$i];
 $i++;
}
$end = microtime(true);

echo $end - $start;
```

## Test 3: array_walk vs loops
| Type | Time |
| ---- | ---- |
| foreach | 0.65 |
| while | 0.69 |
| for | 0.72 |
| array_filter | 0.76 |

```
// array_walk average 0.72 seconds
$start = microtime(true);
$data = array_walk($data, function ($item) {
 return $item+1;
});
$end = microtime(true);

echo $end - $start;

// Foreach loop average 0.65 seconds
$start = microtime(true);
$newData = array();
foreach ($data as $item) {
 $newData[] = $item+1;
}
$end = microtime(true);

echo $end - $start;

// For loop average 0.76 seconds
$start = microtime(true);
$newData = array();
$numItems = count($data);
for($i=0;$i<=$numItems;$i++) {
 $newData[] = $data[$i]+1;
}
$end = microtime(true);

echo $end - $start;

// While loop average 0.69 seconds
$start = microtime(true);
$newData = array();
$numItems = count($data);
$i = 0;
while ($i <= $numItems) {
 $newData[] = $data[$i];
 $i++;
}
$end = microtime(true);

echo $end - $start;
```

## End Notes
I was incorrect when I thought that *array_\** functions are faster! Albeit the speed difference is pretty negligible when talking about using it once or twice during page execution. I won't stop using the *array_\** functions because of my findings, they still offer a cleaner way of writing the code. I will only second guess using them when I am writing code that has the potential to be processed thousands of times.

*I tested these with a pretty basic data set. Speed may vary depending on the type of data being used as well as the version of PHP (I used 5.5.4).*

Are array_* functions faster than loops?


I was working with [Grunt](http://gruntjs.com/) the other day attempting to update some legacy code to use [uglify](https://github.com/gruntjs/grunt-contrib-uglify) and I kept getting errors such as:
```
>> Uglifying source path/to/file.js failed.
Warning: Uglification failed.
Unexpected token punc «(», expected punc «:».
Line 12 in path/to/file.js
 Use --force to continue.

Aborted due to warnings.
```

 When I went to line 12 I saw absolutely nothing wrong. It was a comment block like the following:
 
 ```
 /*
An unobtrusive comment goes here
*/
```

I tried removing the file from the list being included and it happened again. Same error different file. Everything I was reading said it was most likely invalid Javascript doing it, but since I write code perfectly, that could not be the case. Fast forward 10-20 minutes and I found this [issue on Github](https://github.com/mishoo/UglifyJS2/issues/521) that sounded similar. A comment from [Eric Range](https://github.com/ericrange) advised that their code editor had added a line ending of "\n\r" to the file and that caused their build to fail. So I took a look at line endings and sure enough, a handful of the files were using "\n\r". I did a find/replace and changed them all to just a single new line ("\n"). I attempted to uglify it once more and yet again I was shown an error! I was beginning to think uglify and I were not going to be good friends.

```
Running "uglify:build" (uglify) task
{ message: 'Unexpected token: eof (undefined)',
  filename: 'file.js',
  line: 3032,
  col: 0,
  pos: 129381,
  stack: 'Error\n    at new JS_Parse_Error (/path/to/node/node_modules/grunt-contrib-uglify/node_modules/uglify-js/lib/parse.js:196:18)\n    at js_error (/path/to/nodenode_modules/grunt-contrib-uglify/node_modules/uglify-js/lib/parse.js:204:11)\n    at croak (/path/to/nodenode_modules/grunt-contrib-uglify/node_modules/uglify-js/lib/parse.js:678:41)\n    at token_error (/path/to/nodenode_modules/grunt-contrib-uglify/node_modules/uglify-js/lib/parse.js:682:9)\n    at unexpected (/path/to/nodenode_modules/grunt-contrib-uglify/node_modules/uglify-js/lib/parse.js:688:9)\n    at block_ (/path/to/nodenode_modules/grunt-contrib-uglify/node_modules/uglify-js/lib/parse.js:1000:28)\n    at /path/to/nodenode_modules/grunt-contrib-uglify/node_modules/uglify-js/lib/parse.js:974:25\n    at function_ (/path/to/nodenode_modules/grunt-contrib-uglify/node_modules/uglify-js/lib/parse.js:979:15)\n    at expr_atom (/path/to/nodenode_modules/grunt-contrib-uglify/node_modules/uglify-js/lib/parse.js:1187:24)\n    at maybe_unary (/path/to/nodenode_modules/grunt-contrib-uglify/node_modules/uglify-js/lib/parse.js:1357:19)' }
>> Uglifying source path/to/file.js failed.
Warning: Uglification failed.
Unexpected token: eof (undefined).
Line 3032 in path/to/file.js
 Use --force to continue.

Aborted due to warnings.
```

I looked at the differences between the files that worked and the ones that failed. The only difference I found was that the failed files used tabs instead of spaces (they were created at a time when there was no convention for tabs vs spaces). So I converted the files that were using tabs to spaces and tried again. Bingo! It worked perfect.

## Final Solution

My final solution was to change all files to use unix line endings ("\n") and to convert tabs to spaces.

Hello there!