soledad penadés » php

A hack to parse RSS feeds with php

sole — Sat, 21 Jan 2012 17:19:37 +0000

Just happened to assemble this ~~script~~ hack recently, out of the requirement for a quick’n'dirty feed parsing feature:

$feed_contents = file_get_contents($feed_url);

$xml = simplexml_load_string($feed_contents, LIBXML_NOCDATA); 

$feed_array = json_decode(json_encode($xml));

print_r($feed_array); // Surprise!!

Now this evidently is not SimplePie or Magpie RSS or whatever feed reader library tickles your fancy*, but assuming the feed will never be malformed, it can save you lots of time! Isn’t that what php was meant for? :-P

At first it surprised me that it would even work–but it seems that the JSON module interoperates very nicely with SimpleXML objects. At the end you get an associative array in $feed_array which is a nice representation of the RSS 2 feed. It’s important to highlight the LIBXML_NOCDATA parameter, as it makes sure the CDATA nodes are read as text. Otherwise you would just get empty feed items, etc.

Obviously for this to work you need both the JSON and SimpleXML modules installed and enabled in your server. Since that’s something that always worries me, I wrote another quick script to test whether the hack would work on the server:

$functions = array('simplexml_load_string', 'json_decode');

foreach($functions as $f) {

  echo $f . ' exists? ' . (function_exists($f) ? 'yes' : 'no') . '
';

}

It should output something like…

simplexml_load_string yes

json_decode yes

Happy hacking! :-P

Debunking Smarty myths

sole — Mon, 14 Jun 2010 12:12:30 +0000

I have found yet another article condemning the use of Smarty because…

[...] When you add a template language on top of this the template language has to be interpreted, converted to php and then interpreted as php and outputted. This doubles the amount of work that the cpu has to do to return the page the user requested [...]

All right, Toms of the world: did you ever have a look at Smarty’s temporary directory? (hint: it’s usually called templates_c)

Because if you had done so, you would have noticed that the only times the templates are parsed are

a) the first time the template is loaded
b) when the template has been modified

All the other times Smarty simply includes the compiled (read: pre-parsed or generated) templates, which consist in php code! (that can be therefore accelerated with php op-code accelerators)

Now, once you recover from this possibly traumatic revelation, let me tell you something else: you can also cache entire pages with Smarty! And those will hardly involve your php interpreter at all when being served to the user, because most of the content will have already been generated! How smart is that?

I can understand you don’t want to use Smarty because it’s yet another syntax to be learnt, or because you don’t want to add another layer of complexity to your code, or maybe simply because you don’t like its syntax. But give credit where credit is due: Smarty has helped lots of high traffic sites get way further than they would have reached had they relied on php templating only, thanks to Smarty’s cache functionality.

And that’s an achievement few template systems hold.

Delicatessen v2

sole — Tue, 17 Nov 2009 10:27:39 +0000

Let me introduce Delicatessen v2, the new version of my WordPress plug-in for finding out who’s bookmarked your posts in delicious.com

It has taken a bit too long to produce this version, but it at last behaves like a nice netizen, and won’t spam delicious.com with too many queries in a very little time, therefore you won’t get banned ;)

More info and downloads in the Delicatessen page.

SyHi: my minimalistic syntax highlighting plug-in for WordPress

sole — Mon, 02 Nov 2009 12:50:43 +0000

I had been using Code Snippet for a year, or a couple of years (I can’t really remember), and was more or less happy with it. Apart from the fact that it didn’t preserve some stuff properly, like double dashes and quotes. So then I tried adding another plug-in to the mix, Preserve Code Formatting. But both at the same time didn’t work out as I ~~expected~~ hoped.

The solution?

I made a new plug-in. It’s very minimalistic, starting with its name: SyHi.

How does it work?

The problem with other plug-ins is that they apply their formatting and then let WordPress continue modifying the posts’ text. That’s a totally bad idea, and that’s why quotes and dashes were systematically altered. On the other hand, this little clever plug-in takes the code blocks apart, sets them aside while leaving placeholder text where they were, and when WordPress has finished with all its filtering and texturizing, SyHi replaces the placeholder texts with the preserved, syntax highlighted beatiful pieces of code that the author entered.

The resulting code not only is nice to look at, but can be copied and pasted into a compiler and it will work with no modifications at all. No more please replace em dashes with double hyphens because WordPress modified the snippet’s output…: your blog readers can now simply copy and paste!

Alphatesters needed

So far I have tested SyHi with a test blog and this blog too. It looks fine, but I would be more than happy if somebody else wants to have a go at testing it. I would even add you to the Thanks section!

~~Unfortunately, the plug-in is not yet available in the wp-plugins directory; I’m waiting for them to approve my request so that you can install it from within the plugins admin page.~~

Plug-in page at WordPress directory: SyHi. You can also clone the SyHi github repository or download the latest version from there.

Samples

So you don’t believe me when I say this plug-in works great?

Using Python

noise_output = wave.open('noise.wav', 'w')

noise_output.setparams((2, 2, 44100, 0, 'NONE', 'not compressed'))



for i in range(0, SAMPLE_LEN):

        value = random.randint(-32767, 32767)

        packed_value = struct.pack('h', value)

        noise_output.writeframes(packed_value)

        noise_output.writeframes(packed_value)



noise_output.close()

What about php?

class SyHi

{

        protected $code_blocks;

        protected $geshi_instance = null;



        public function __construct()

        {

                // Execute pre and post process functions before and after each post content is processed

                add_filter('the_content', array(&$this, 'pre_process'), 2);

                add_filter('the_content', array(&$this, 'post_process'), 1000);



                // Same for each comment

                add_filter('comment_text', array(&$this, 'pre_process'), 2);

                add_filter('comment_text', array(&$this, 'post_process'), 1000);



                // Add the css stylesheet link to the 

                add_action('wp_head', array(&$this, 'add_css'), 1);

        }

}

OK and what about C/C++?

void luisita_reportErrors(lua_State *L, int st)

{

    if (st != 0)

    {

        std::cerr << "ERROR -- " << lua_tostring(L, -1) << std::endl;

        lua_pop(L, 1); // removes error message

    }

}

As you can see, double dashes are being respected, quotes are kept as they are, and code is nicely highlighted. And if you’re still feeling skeptical, keep browsing posts in this blog, since all code snippets go through SyHi.

Update: added the link to the plug-in’s repository :)

Update 2: let me clarify something: this plug-in can beautify snippets in pretty much every programming language you can think of, thanks to the huge language support provided by GeSHi. I have shown you only three examples as a simple demonstration, but you can even show Z80 assembler code!

The full list of supported languages is in the left column of the GeSHi website, under the Supported Languages header. Heck, it even has support for a language called BrainFuck!

“Blue Tuesday” sources released

sole — Fri, 10 Jul 2009 11:35:25 +0000

“Blue Tuesday” is a direct evolution from the codecolors code base. Since it was all done in a hurry, there were lots of things which didn’t work as expected. I somehow got rid of some of them when I ported the demo to mac, then I got rid of some extra things these days when I made the demo work in Linux, prior to releasing these sources. I am not happy with this code; with so many modifications it has grown way too much to be still readable. There are effects whose behaviour is not predictable, things like the ribbons are very inefficient and so on.

I’m still not completely happy with the synchronization. In the first version trace did a simple flash app in which he tapped a key each time an event happened (e.g. a snare hit) and then generated a list from there. But due to the way the demo is structured, I had to split the list in three parts so that I could check whether an event happened in each effect. Also with so many changes in the code, the synch had gone slightly awry and when I managed to compile the code in Linux, it clearly was asking for a revision.

So I thought about using Audacity for re-recording the synchronization. I would store each event as a label (Audacity has something called Label Tracks) and then exporting those labels as txt files and processing them to convert them into a .h file with all the events in an array. I had the idea of opening Audacity’s project with a text editor and found out that it was a simple XML file — which would make even easier the task of importing the labels’ information, without having to go through the step of exporting to a text file and parsing it.

I then tried to process the XML file with Python, but it was a horrible experience. Since it has a namespace on it and I wanted to do a simple XPath search, it seems I was doomed to fail without installing a couple of Python libraries — which I didn’t want to install. My main premise is to make my demos simple to compile, and having to install an extension just for parsing XML is not what I consider “simple”. So I resorted to good old PHP’s XML functions and in 20 minutes the import script was done. That was the easy part.

What was really painful was recording the synch points! Audacity took hanging itself up as a hobby. Thankfully, I have the CTRL+S tic –in which whenever I’m working with any program I tend to press CTRL+S regularly, pretty much each time I have typed in something, just in case– and that prevented me from losing my changes more than once. But it was just annoying to have to kill the program, open it again, say yes to “yes please recover the project I was working on when you decided to crash”. Even worse: at some point, the project got corrupted, and when I reopened it again, Audacity just got stuck switching between an sleep/idle status. I had to create a new project with the same mp3, save it and then edit the new project in a text editor, and copy and paste the old label tracks from the initial source project. Luckily it was all XML. I can’t imagine what would have I done if it had been binary data! (Probably scream a good lot!)

So lesson learnt: for making good synchronization you need a dedicated, and probably integrated, piece of software. If I need to do something like this again, I will probably spend a good amount of time in preparing something like the editor blackpawn created. Because it wasn’t only a problem of crashing, it was also the problem of not having a comfortable interface which lets you go back and forth the song, reduce its speed, etc, without having to use the mouse.

This is probably one of the reasons why I prefer to make demos with my own music: it’s easier to access the original song source files and build a list of events from there if I wanted to :-)

Enough chattering, go watch the demo or get a nice headache just by looking at the code :P