Needed one a while ago, but the ones I found were either kind of lacking or kind of old. So I made one myself by converting a datafile on Wikipedia into the format I wanted. Used some regular expressions and manual corrections. Later I also went through newsletters with Updates on ISO 3166. Hopefully I got it all right, and hopefully it can save you and others some time as well.

If you find any mistakes or updates I’ve missed, please let me know

The data

Created a project on BitBucket for some change tracking. The latest version of the SQL script is found at bitbucket.org/svish/iso-3166-country-codes/src/default/countries.sql.

Also included a copy of the latest version below. If you want to be 100% sure you get the latest, use the link above though. I might forget to update the post ;)

What is valid?

To figure that out, we need a look in the ECMAScript Language Specification. In chapter 13 on functions, we find that a function name is a so-called identifier, which is described in chapter 7.6. There we can find the following facts:

Identifier	<IdentifierName> but not <ReservedWord>
IdentifierName	<IdentifierStart> <IdentifierName> <IdentifierPart>
IdentifierStart	<UnicodeLetter> $ _ \ <UnicodeEscapeSequence>
IdentifierPart	<IdentifierStart> <UnicodeCombiningMark> <UnicodeDigit> <UnicodeConnectorPunctuation> <ZWNJ> <ZWJ>
UnicodeLetter	Uppercase letter (Lu) Lowercase letter (Ll) Titlecase letter (Lt) Modifier letter (Lm) Other letter (Lo) Letter number (Nl)
UnicodeCombiningMark	Non-spacing mark (Mn) Combining spacing mark (Mc)
UnicodeDigit	Decimal number (Nd)
UnicodeConnectorPunctuation	Connector punctuation (Pc)
UnicodeEscapeSequence	The definitions of the nonterminal UnicodeEscapeSequence is given in 7.8.4
ZWNJ	U+200C (Zero-width non-joiner
ZWJ	U+200D (Zero-width joiner
ReservedWord	<Keyword> <FutureReservedWord> <NullLiteral> <BooleanLiteral>
Keyword	break, do, instanceof, typeof, case, else, new, var, catch, finally, return, void, continue, for, switch, while, debugger, function, this, with, default, if, throw, delete, in, try
FutureReservedWord	class, enum, extends, super, const, export, import implements, let, private, public, yield, interface, package, protected, static
NullLiteral	null
BooleanLiteral	true, false

Looks long, but not too complicated.

Checking if a string is valid

To check if a string is a valid identifier is now pretty easy. We just need to make sure the string matches the allowed syntax, and that it’s not a reserved word. The first we can solve with a regular expression and the second with a simple white list array. For example, something along the following lines.

Not too complex, although the regular expression might look a bit nuts at first because of all the Unicode character groups. You might find regular expressions other places to do this that uses a-z for the letters, but as you saw from the specification that won’t cover much of what’s actually valid.

I built the expression using the very helpful RegexBuddy and exported an HTML explanation of it. Also threw together a tiny identifier validator thing where you can test it out with. You find it all at samples.geekality.net/js-identifiers.

And that’s that. Hope that might be helpful for someone and please let me know if you find any issues with it!

Note: I have ignored the issue with the Unicode escape sequences for now as I’m not quite sure how to best handle those. From the specification:

A UnicodeEscapeSequence cannot be used to put a character into an IdentifierName that would otherwise be illegal. In other words, if a \UnicodeEscapeSequence sequence were replaced by its UnicodeEscapeSequence’s CV, the result must still be a valid IdentifierName that has the exact same sequence of characters as the original IdentifierName. All interpretations of identifiers within this specification are based upon their actual characters regardless of whether or not an escape sequence was used to contribute any particular characters.

So, I’m not sure if there is a way to just convert those sequences into actual characters or if this is done automatically by PHP as they come in as GET parameters or what. Either way, my code above there is ignoring them. This means, identifiers with escape sequences will not be considered valid. If you have some good ideas on how to handle it, please leave a comment

Lists all your tags, sorted by name

rgbstock.com

Found an article which explained pretty well why I was a bit confused. It also had a code example in Perl(?).

So, thought I could stick a PHP version here in case that page dies or I forget. Actually there are two. The first calculates the age kind of manually, and can be used in PHP 4 and PHP 5. The second is a lot shorter and simpler, but requires PHP 5.3.

Enjoy

This next function uses the DateTime::diff method available in PHP 5.3.

You can test them out at samples.geekality.net/age

Instant Payment Notification (IPN) is a message service that notifies you of events related to PayPal transactions. You can use it to automate back-office and administrative functions, such as fulfilling orders, tracking customers, and providing status and other information related to a transaction. — PayPal

Once again the documentation, tutorials and code samples I found on this was a bit all over the place. Sort of messy and outdated. So, once again I decided to do my own thing and just follow the steps required and implement them myself. And since the tutorial on PDT turned out to be a bit of a success, I decided to share this too. Hopefully it can make the lives of fellow developers easier

How it works

The concept is pretty simple. You first give PayPal an address to a listener, for example http://business.example.com/ipn/listener.php. Then, whenever something happens, PayPal will post information about the event to that address. So for example if someone completes a payment, your listener will be notified shortly after with the transaction details and all you need to know.

This tutorial will focus on the listener part, as the setting up part on PayPal is very simple (Leave a comment if you disagree). Just go to the PayPal account settings, find the IPN settings and give the URL to your IPN listener. For testing we don’t even need to do that. All we need to do is to set up a PayPal Developer Account. We can then use their very handy Instant Payment Notification (IPN) simulator that you find among their Test Tools. So let’s get started!

Step 0: Sign up for a Developer Account

If you haven’t, go sign up for a PayPal Developer account. We don’t need to set up any accounts this time, as we will simply use the mentioned simulator.

Using the simulator is ultra simple. You just enter the address of your listener and choose a transaction type. You can then fill out all the data that should be in this fake transaction and then just hit “Send IPN” at the bottom. Luckily PayPal actually fills out all the fields with random test data, so unless you are trying to test something specific, you can just ignore the data and hit the button right away

Now, to the actual listener file…

Step 1: Catch the IPN

First thing we need to do in our listener is of course to catch the data we get from PayPal. The data is sent as a POST request, so PHP has actually done that for us. We just need to grab it

Step 2: Verification

Since what we got could just be plain bogus from some stranger, we need to verify it with PayPal. This is done by taking all the POST data in its unaltered state, add one field to the beginning, and then send it back. In return we should then get one word, VERIFIED or INVALID. To do that, we can use our old buddy cURL.

Note that in the very beginning actually check for a field called test_ipn. If that exists with a value of 1, it means it’s a request from the sandbox. In other words, we can choose the correct PayPal interface by just looking for that.

You can also see I set two cURL options called SSL_VERIFYPEER and CAINFO. The reason for that you will find in my post on cURL SSL verification.

Step 3: Fix character set

Now that we know the data is valid, we can start to deal with it. What you get could be in a different character set than what you want though, so we should fix that first. The data should contain a key called charset which specifies what character set the data is using. We just need to check for that and if needed convert from that to what we want, for example UTF-8.

Step 4: Use the data!

Yup, believe it or not, that was everything that was needed to catch an IPN message from PayPal. Where you go from here completely depends on what exactly you need to do.

What you at least should do is the following:

1. Confirm that the payment status is Completed.
   PayPal sends IPN messages for pending and denied payments as well, so don’t ship stuff or anything until the payment has cleared.
2. Use the transaction ID to verify that the transaction has not already been processed.
   This prevents you from processing the same transaction twice. You can for example store the transaction id in a database and check against those before you do anything with incoming IPNs. If you’re smart you could also store the time the IPN came in and the raw IPN data. This way you have a log of all incoming messages you can use if you need to reprocess something or for debugging if something weird is going on.
3. Make sure the receiver’s email address is the one you expected.
4. Make sure the price, item description, et cetera, match what it should be.

And then finally you should of course make sure your customer gets what they should

You can read more about PayPal Instant Payment Notifications in their IPN Guide.

Working sample

I have put together a working sample you can check out over at samples.geekality.net/ipn. Hopefully this tutorial and that sample can help you get started with all of this

I also put together an IPN handler class you can use pretty much out of the box. The sample uses it, and it’s very simple. Just extend the class, override the process method and do what you need. Below is a simple example.

That’s all! I’m sorry it took so long to get this tutorial written, but hopefully someone can find it useful. I have learned a lot writing it at least! Please leave a comment if it was helpful, if it wasn’t helpful, if there are mistakes, typos, or if you just want to say thank you

Found some versions, but they were either a bit messy or depended on unstable arithmetic (where filesize is greater than PHP_INT_MAX). So, I decided to take on the challenge and try to write one myself. Nice little exercise

My result looks a bit long, but that’s mostly because I have added lots of comments here so you can hopefully understand what’s going on

Sample

You can try out a slightly modified version at samples.geekality.net/tail. Of course you won’t be able to try it on your multi-gigabyte-sized log file, but at least you can see if it does what it should

As usual, if you have any corrections or feedback, if you found it useful, please leave a comment!

Found some pieces of code here and there, added some of my own and ended up with a LineReader class. Works as far as I can see, but let me know if you test it out and you find any bugs

You can use it in a streaming fashion:

Or grab all the lines at once:

Let me know what you think! Feedback is welcome as always