Da qualche giorno, infatti, è possibile sostituire il classico codice di tracciamento, con una nuova versione che permette il caricamento asincrono del file ga.js, portando benefici ai tempi di caricamento delle pagine che utilizzano Google Analytics.

La libreria, utilizzando il codice originale di GA, si utilizza in questo modo:

<script type="text/javascript">
var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
</script>

<script type="text/javascript">
try {
var pageTracker = _gat._getTracker("UA-XXXXXXX-1");
pageTracker._trackPageview();
_ftTrack(pageTracker,"link|pdf|jpg|zip|rar");
} catch(err) {}
</script>

Utilizzando invece il nuovo codice, il richiamo della funzione _ftTrack va modificato in questo modo:

<script type="text/javascript">

  var _gaq = _gaq || [];
  _gaq.push(['_setAccount', 'UA-XXXXX-X']);
  _gaq.push(['_trackPageview']);
  _gaq.push(function(){
    _ftTrack(_gaq._getAsyncTracker(), "link|pdf|jpg|zip|rar");
  });

  (function() {
    var ga = document.createElement('script');
    ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
    ga.setAttribute('async', 'true');
    document.documentElement.firstChild.appendChild(ga);
  })();

</script>

Allo stesso modo, per tracciare informazioni distinte in due account, con il codice ufficiale la libreria si utilizza così:

<script type="text/javascript">
var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
</script>

<script type="text/javascript">
try {
var pageTrackerA = _gat._getTracker("UA-XXXXXXX-1");
pageTrackerA._trackPageview();

var pageTrackerB = _gat._getTracker("UA-XXXXXXX-2");
pageTrackerB._trackPageview();

_ftTrack(pageTrackerA,"pdf|jpg|zip|rar");
_ftTrack(pageTrackerB,"link");
} catch(err) {}
</script>

Utilizzando invece il codice di tracciamento asincrono, avremo qualcosa del genere:

<script type="text/javascript">

  var _gaq = _gaq || [];
  _gaq.push(['_setAccount', 'UA-XXXXX-1']);
  _gaq.push(['_trackPageview']);
  _gaq.push(function(){
    _ftTrack(_gaq._getAsyncTracker(), "pdf|jpg|zip|rar");
  });

  _gaq.push(['b._setAccount', 'UA-XXXXX-2']);
  _gaq.push(['b._trackPageview']);
  _gaq.push(function(){
    _ftTrack(_gaq._getAsyncTracker('b'), "link");
  });

  (function() {
    var ga = document.createElement('script');
    ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
    ga.setAttribute('async', 'true');
    document.documentElement.firstChild.appendChild(ga);
  })();

</script>

A questo punto potrebbe essere utile sapere in quale file una funzione o una classe è stata definita. Oppure sapere da quale classe un oggetto è stato istanziato.

Fortunatamente a partire da PHP5 abbiamo a disposizione una serie di API per la Reflection che rendono questo compito molto semplice.

Per ottenere informazioni su una funzione:
<?php ReflectionFunction::export('nomeDellaFunzione') ?>

Per ottenere informazioni su una classe:
<?php ReflectionClass::export('nomeDellaClasse') ?>

Per ottenere informazioni su un oggetto:
<?php ReflectionObject::export($object) ?>

Un rapido esempio in un file “reflection.php”:

<?php

class Test
{

}

function Test() {
    return new Test;
}

$test = Test();

echo "<pre>";

ReflectionFunction::export('Test');
ReflectionClass::export('Test');
ReflectionObject::export($test);

L’output è:

Function [  function Test ] {
  @@ /var/www/reflection.php 8 - 10
}

Class [  class Test ] {
  @@ /var/www/reflection.php 3-6

  - Constants [0] {
  }

  - Static properties [0] {
  }

  - Static methods [0] {
  }

  - Properties [0] {
  }

  - Methods [0] {
  }
}

Object of class [  class Test ] {
  @@ /var/www/reflection.php 3-6

  - Constants [0] {
  }

  - Static properties [0] {
  }

  - Static methods [0] {
  }

  - Properties [0] {
  }

  - Dynamic properties [0] {
  }

  - Methods [0] {
  }
}

new GMap.Map("Milano, Italy", "map_canvas")
    .mark("Via Pomponio 4")
    .mark("Corso di Porta Ticinese");

Una demo qui. Da notare che in mark non è necessario specificare una città, dato che verrà cercata la Via Pomponio e il Corso di Porta Ticinese più vicino al centro della mappa (Milano nell’esempio) :-)

Sarebbe bello avere un’interfaccia completa in stile jQuery per lavorare con le API di Google Maps, penso che aprirebbe la strada ad un’infinità di Web Application basate sulle mappe di Google :P

Chissà che John Resig non abbia un po’ di tempo libero :D

Il problema si presenta in questo modo: gli obbiettivi vengono tracciati correttamente, ma il tasso di abbandono tra gli step intermedi è dello 0%.

Un problema simile nelle cause, sempre segnalato dal post di Lunametrics, si presenta in questo modo: dai report risulta che ci sono state conversioni, ma il report dei funnel mostra un tasso di abbandono del 100% tra il primo ed il secondo step.

Entrambi i problemi si verificano quando il tipo di corrispondenza dell’obbiettivo è settato a Corrispondenza principale o Corrispondenza espressione regolare ed è causato dal fatto che uno step cattura anche i successivi.

L’unico modo per risolvere è ricorrere ad espressioni regolari (o intervenire sul sito web al fine di modificare gli URL degli step :P), Lunametrics suggerisce di ricorrere ad espressioni regolari avanzate con asserzioni negative che “guardano avanti”, proponendo anche un link di approfondimento. In realtà penso che nella maggior parte dei casi si possa ricorrere ad espressioni meno avanzate e forse anche più precise.

Immaginiamo un caso del genere:

Step 1: /sottoscrizione/
Step 2: /sottoscrizione/step2.php
Obiettivo: /sottoscrizione/grazie.php

Il problema è catturare al primo step, senza catturare gli step successivi, tutti gli URL del tipo:

/sottoscrizione/
/sottoscrizione/?query_string
/sottoscrizione/index.php
/sottoscrizione/index.php?query_string

L’espressione che ho pensato per questo specifico problema, ma che può essere facilmente riadattata anche alla maggior parte dei problemi simili, è la seguente:

^/sottoscrizione(/|/\?.+|/index.php.+)$
^/sottoscrizione(/|/\?.*|/index.php.*)$

In pratica con questa espressione definiamo una regola che cattura gli URL esattamente uguali a “/sottoscrizione/” OPPURE “/sottoscrizione/?” + qualsiasi o nessun carattere OPPURE “/sottoscrizione/index.php” + qualsiasi o nessun carattere.

Per capire meglio il report sui funnel di Google Analytics, rimando al post di Lunametrics.

[Ne approfitto per segnalare con qualche mese di ritardo il guest post che ho avuto il piacere di pubblicare su GoAnalytics di Marco Cilia, un blog e leggo sempre con molto interesse. Il post è giusto una raccolta di qualche nota su il codice di Google Analytics da includere nelle pagine]

Aggiornamento:
Vuoi utilizzare questa libreria con il nuovo codice di tracciamento asincrono di Google Analytics? Scopri come.

L’utilizzo è davvero semplice, per prima cosa dobbiamo scaricarla ed includerla nelle nostre pagine:

<script type="text/javascript" src="_ftTrack.js"></script>

Dopo di che ci basta aggiungere il richiamo di una funzione dopo il normale codice di Google Analytics (è evidenziato in grassetto nel seguente esempio):

<script type="text/javascript">
var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
</script>

<script type="text/javascript">
var pageTracker = _gat._getTracker("UA-XXXXXXX-1");
pageTracker._initData();
pageTracker._trackPageview();
_ftTrack(pageTracker,"link|pdf|jpg|zip|rar");
</script>

La funzione _ftTrack accetta due argomenti, il primo, quello che rende la libreria multi account, è l’oggetto di Google Analytics creato con _gat._getTracker("UA-XXXXXXX-1") (pageTracker, nell’esempio), il secondo è l’elenco delle estensioni dei file da tracciare separate da un | (pipe).

Per tracciare i link esterni, basta aggiungere all’elenco di estensioni (nell’esempio pdf|jpg|zip|rar), la parola chiave “link”:

_ftTrack(pageTracker,"link|pdf|jpg|zip|rar");

Non dovete fare altro :-)

La libreria _ftTrack incorpora la libreria onContent scritta da Andrea Giammarchi.

Dove ritrovo i dati tracciati?

La libreria traccia i click su link in uscita ed i link verso file non HTML come pagine visualizzate. Questo significa che li ritroverete in ogni report sulle pagine visualizzati di Google Analytics.

Tutte le “finte” pagine viste hanno un prefisso predefinito: “/OUTGOING/” per i link in uscita e “/MEDIA/” per gli altri file.

Ci sono problemi con più account di Google Analytics?

No, la libreria gestisce ogni account di Google Analytics in modo separato. Quindi inserendo più codici in una pagina possiamo scegliere cosa tracciare per ognuno. Nel seguente esempio il primo account traccia SOLO link esterni ed il secondo SOLO file PDF:

<script type="text/javascript">
var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
</script>

<script type="text/javascript">
var primoTracker = _gat._getTracker("UA-XXXXXXX-1");
primoTracker._initData();
primoTracker._trackPageview();

var secondoTracker = _gat._getTracker("UA-XXXXXXX-2");
secondoTracker._initData();
secondoTracker._trackPageview();

_ftTrack(primoTracker,"link");
_ftTrack(secondoTracker,"pdf");
</script>

Nel post di Marco trovate un altro esempio molto interessante, in cui non si utilizza il richiamo alla funzione _trackPageview(). Questo permette di fatto di dedicare un account al solo tracking di download e link in uscita.

Tips

Per testare la libreria, dopo averla scaricata ed inclusa in un documento, potete sostituire il codice di Google Analytics con questo:

<script type="text/javascript">
function testObj(){
	this._trackPageview=function(msg){
		window.alert(msg);
	}
}
pageTracker = new testObj();

_ftTrack(pageTracker,'link|pdf');
</script>

Con questo codice, per ogni link esterno e link a file PDF cliccato, otterrete un alert con la pagina che la libreria salverebbe in Google Analytics, ho messo anche un esempio on line. Molto utile in fase di debug :-)

Se state ancora utilizzando il vecchio codice di GA, potete far riferimento a questo vecchio post.

Si ricava il codice decimale del carattere nella tabella ASCII, gli si cambia base (da base 2 a base 10) e quello che otteniamo è un numero binario. Ecco un esempio in Javascript:

// binaries and ascii
function asciiToBin(string){
	var bin='';
	for(i=0;i<string.length;i++){
		bin+=strPadLeft(string.charCodeAt(i).toString(2),8);
	}
	return bin;
}

function strPadLeft(n,l){
	while(n.length<l){
		n='0'+n;
	}
	return n;
}

Anche in questo caso utilizziamo toString per cambiare base ad un numero, e la funzione strPadLeft per “riempire” di zeri i numeri più corti di otto caratteri.

Per la riconversione in ASCII le cose si complicano un po’, infatti in questo caso non abbiamo una funzione simile a unescape che fa ritornare tutto come prima.

Per la riconversione potremmo quindi utilizzare la funzione di Javascript parseInt per ogni ottavina (serie di otto bit) ottenuta.

Infatti utilizzata in queso modo, la funzione parseInt converte il numero binario 00000011 in numero decimale:

parseInt('00000011', 2);

Il risultato sarebbe 3.

Ecco di seguito una funzione di conversione ASCII binario che utilizza la funzione parseInt:

function binToAscii(bin){
	var ascii='';
	for(var i=0;i<bin.length;i+=8){
		ascii += String.fromCharCode(parseInt(bin.substr(i,8),2));
	}
	return ascii;
}

In alternativa potremmo utilizzare una funzione più teorica. Per convertire un numero da qualsiasi base numerica in basa decimale, si prende il numero di minor peso (quello più a sinistra) e lo si moltiplica per la sua base elevata alla zero. Il risultato viene sommato al secondo numero moltiplicato per la sua base elevata alla prima e così via.

Quindi un numero in base 2 (binario) come il seguente, potrebbe essere trasformato in numero decimale nel seguente modo:

101 = (1*2^0)+(0*2^1)+(1*2^2) = 1+0+4 = 5;

Possiamo riprodurre la stessa logica con una funzione:

function byteToDecimal(by){
	var dec = 0;
	for(var i=0;i<by.length;i++){
		dec += Math.pow(2,i)*by.substr(by.length-(i+1),1);
	}
	return dec;
}

Per chi fosse interessato rimando a questo articolo sui sistemi di numerazione per approfondimenti.

Ad esempio la stringa http://www.asciitable.com passata in una di queste funzioni diventerebbe qualcosa tipo http%3A%2F%2Fwww.asciitable.com.

L’escape di un carattere non è altro che il suo corrispondente esadecimale preceduto da un “%”. Per i 255 caratteri ASCII si fa quindi riferimento a questa tabella (che contiene solo i primi 127, per gli altri potete seguire il link dopo l’immagine):

Tabella ASCII: www.asciitable.com

Se il carattere slash “/”, nella tabella ASCII, corrisponde al numero decimale 47 ed al numero esadecimale 2F, il suo escape sarà %2F.

Anche se le succitate funzioni convertono solo alcuni caratteri, non significa che tutti gli altri non possano essere convertiti.

Per fare l’escape completo di una stringa, quindi, non ci resta che individuare il valore decimale di ogni carattere, convertirlo in numero esadecimale (a larghezza fissa di due cifre) e farlo precedere da un “%”.

Per le stringhe di caratteri ASCII sia Javascript che PHP ci vengono in aiuto con alcune funzioni per la conversione dei caratteri nel loro valore decimale all’interno della tabella ASCII, quindi una volta ottenuto il valore decimale, ci basta convertirlo in esadecimale trasformandolo da numero in base dieci a numero in base 16.

Di seguito il codice pronto per il copia e incolla in Javascript:

function escapeAll(string){
	var hex='';
	for(i=0;i<string.length;i++){
		hex+='%'+strPadLeft(string.charCodeAt(i).toString(16),2);
	}
	return hex.toUpperCase();
}
function strPadLeft(n,l){
	while(n.length<l){
		n='0'+n;
	}
	return n;
}

Nella funzione escapeAll, per ottenere il codice ASCI di ogni carattere, si utilizza charCodeAt. Di seguito un esempio per chiarirne l’utilizzo:

var string = "Hello World";
string.charCodeAt(0); // Ritorna il codice ASCII (decimale) di "H"
string.charCodeAt(1); // Ritorna il codice ASCII (decimale) di "e"
string.charCodeAt(2); // Ritorna il codice ASCII (decimale) di "l"
string.charCodeAt(3); // Ritorna il codice ASCII (decimale) di "l"
string.charCodeAt(3); // Ritorna il codice ASCII (decimale) di "o"
...

Una volta ottenuto il codice ASCII (un numero decimale) dobbiamo quindi trasformarlo in numero esadecimale (che è un numero in base 16). Per cambiare base ad un numero decimale viene utilizzata la funzione toString. Di seguito un esempio:

var num = 16;
while(num--){
	document.write(num.toString(16));
}

Lo script stamperà i numeri compresi dal 15 allo zero in base 16 (esadecimali):

f
e
d
c
b
a
9
8
7
6
5
4
3
2
1
0

Per il resto niente da dire, c’è solo in più una funzione strPadLeft che viene utilizzata per assicurarsi che il codice esadecimale del carattere sia lungo 2 cifre, nel caso sia più corto aggiunge uno zero di riempimento a sinistra del numero (in pratica se gli passiamo F, ritorna 0F).

Di seguito il codice in PHP per ottenere lo stesso risultato (l’escape di una stringa):

function rawstringencode($string){
   $hex = '';

   for($i = 0, $j = strlen($string); $i < $j; $i++)
      $hex .= '%'.str_pad(base_convert(ord($string[$i]), 10, 16), 2, '0', STR_PAD_LEFT);

   return strtoupper($hex);
}

Lo script PHP fa la stessa identica cosa di quello in Javascript, le uniche differenze sono i nomi delle funzioni ed il fatto che si usano in modo leggermente diverso.

Applicazioni

Alcune possibili applicazioni potrebbero essere l’offuscamento di codice Javascript oppure la criptazione di stringhe. Ecco due semplici esempi:

Un alert in Javascript:

<script>eval(unescape('%61%6C%65%72%74%28%22%68%65%6C%6C%6F%20%77%6F%72%6C%64%22%29'));</script>

Una criptazione in Javascript che esegue una semplice operazione aritmetica con il codice ASCII del carattere:

function simpleEncrypt(string){
	var new_string='';
	for(var i=0;i<string.length;i++){
		new_string += String.fromCharCode(255-string.charCodeAt(i));
	}
	return new_string;
}
function simpleDecrypt(string){
	return simpleEncrypt(string);
}

In un prossimo post le funzioni per la conversione ASCII binario, binario ASCII, ma più o meno è la stessa cosa :-)

Per approfondire:

Alcuni link più o meno a tema:

• Fondamenti di Informatica » Sistemi di numerazione
• PHP and JavaScript encoding comparison table
• JavaScript String Object Reference
• String Funcions di PHP
• La decodifica automatica di semplici javascript offuscati e criptati
• Invio e ricezione di caratteri (Ajax)

Sulla pagina del nuovo Splinder Importer per Wordpress tutte le informazioni ed il link per il download.

Oltre che alla riconoscenza nei confronti di Fullo per il suo gentilissimo lavoro non retribuito, credo sia d’obbligo un ringraziamento anche all’insistenza di Beggi :D

Si possono creare facilmente gadget, integrare video nei propri siti web o nelle proprie applicazioni (web e non), fino a, potenzialmente, creare una copia di YouTube con una nuova interfaccia creata a nostro piacimento.

Si puÃ?² partire da una semplice richiesta, che esegue una ricerca in YouTube e ritorna un feed Atom con tutte le informazioni su ogni video dei risultati: categorie, tag, autore, lunghezza del filmato, feed con altre informazioni sull’autore, feed dei commenti al video, feed ai video correlati… praticamente ogni informazione relativa alla ricerca e ad ogni singolo video nei risultati.

Con questi dati possiamo facilmente ricreare una pagina dei risultati a nostro piacimento, ma se non abbiamo particolari esigenze, ancora più facilmente, riutilizzare una versione preformattata fornita direttamente nel feed. Questo è il risultato:

	Loli & the Chones -- "You're So Cool" I quit drinking.	From: dipsetmuthafucka Views: 370 8 ratings
	Time: 01:10	More in Music

Da qui a fare un semplice motore di ricerca video bastano davvero poche righe di codice.

Ecco due esempi interessanti di utilizzo delle API di YouTube:

1. YouTube Badge, un’idea semplice e carina per linkare il proprio profilo di YouTube sul nostro sito web o nelle pagine dei nostri profili sparsi per la rete. Ecco come appare:
   
   Get your own youTube badge
2. Personalmente sono rimasto molto colpito dall’idea di Virtual Video Map, un integrazione delle API di YouTube con quelle di Google Maps. Suggestivo quanto inutile :D

Altri esempi nell’apposito forum.

Per chi è interessato ad approfondire l’argomento delle API di YouTube, ecco qualche link:

• La Developer Area su YouTube, con i link alle principali risorse dedicate agli sviluppatori.
• YouTube Data API Protocol, la documentazione principale per interagire con YouTube utilizzando le nuove API introdotte da Google.

Partendo da queste pagine potete facilmente trovare esempi, documentazione, forum di discussione per confrontarsi con altri sviluppatori, librerie e classi in diversi linguaggi. Buon divertimento! :D

Per trasferire i dati da un vecchio database MySQL 4 verso un nuovo e fiammante MySQL 5, esiste sicuramente un metodo per non incasinare le lettere accentate ed i caratteri speciali, ma io al primo tentativo non l’ho imbroccato :D

CosÃ?¬, piuttosto di cancellare, esportare, reimportare… insomma: andare a tentativi, ho scritto un mini script in PHP per riconvertire in UTF-8 il character encoding di post e commenti. Se qualcuno lo vuole riutilizzare il codice è on line.

Lo script è da mettere nella root dell’installazione di WordPress e da lanciare via browser (non serve nessuna personalizzazione).

Volendo è facilmente riutilizzabile anche al di fuori di WordPress. Basta sostituire:

require('wp-blog-header.php');

Con il codice di connessione e selezione del database, e personalizzare la variabile $select, che è un’array multidimensionale con questa struttura:

$select = array(
	$nome_tabella => array(
		'$id_record',
		"SELECT $id_record, $campi_testuali_da_convertire_in_utf8 FROM $nome_tabella"
	),
	...
);

Ma ora mi viene anche un dubbio… non esiste una query SQL che possa sostituire questo script?

Colpa di un escape. La causa sembra un apostrofo senza escape in una variabile Javascript.

Chi non riesce a dormire sereno senza prima controllare le proprie statistiche, nell’attesa di un \ da parte del team tecnico di Google Analytics, puÃ?² modificare la lingua nel proprio profilo utente e continuare ad usufruire a pieno di Google Analytics.

Thu, 29 Jul 2010 18:05:01 GMT

In PHP, una data formattata secondo questa convenzione, si ottiene nel seguente modo:

<?php echo date('D, d M Y H:i:s') ?> GMT

MySQL + date_format()

Comunque, nella creazione di un feed RSS con dati estratti da un database MySQL, puÃ?² essere più comodo utilizzare la funzione di MySQL date_format per ottenere una data formattata direttamente dal database:

SELECT
   date_format(data, '%a, %d %b %Y %H:%i:%s GMT') AS pubDate
   FROM items;

Naturalmente il campo “data” deve essere di tipo DATE, DATETIME o TIMESTAMP.

Creare un feed RSS

Ecco quindi uno snippet per stampare gli item di un ipotetico feed RSS:

<?php
$get = mysql_query('SELECT
   link, title, description,
   date_format(data, "%a, %d %b %Y %H:%i:%s GMT") AS pubDate
   FROM `items` ORDER BY data DESC');

while($r = mysql_fetch_assoc($get)){
echo <<<ITEMS
<item>
   <title>$r[title]</title>
   <description>$r[description]</description>
   <pubDate>$r[pubDate]</pubDate>
   <link>$r[link]</link>
</item>
ITEMS;
}
?>

Parsing di un feed RSS

Nel parsing di un feed solitamente il problema è il contrario, si ha una stringa che rappresenta una data, mentre noi vorremmo un formato più riutilizzabile.

Per risolvere ci viene incontro strtotime, una comoda funzione di PHP: La funzione aspetta di avere una stringa contenente un formato di data in Inglese e proverÃ?  a passare questo formato all’UNIX timestamp.

<?php
echo strtotime('Thu, 16 Aug 2007 16:51:25 GMT');
// Il risultato sar�  1187283085
?>

Per maggiori dettagli sull’iniziativa vi rimando al post originale, ma, in breve, si tratta di un’intervista a Leonardo Bellini, autore del libro Fare business con il web e consulente di comunicazione, web marketing e chissÃ?  quante altre cose…

L’intervista si svolgerÃ?  nei prossimi giorni e le domande, be’, le potete scegliere un po’ voi. Ma c’è una cosa che non mi è chiara, e spero che Vincenzo me la possa spiegare, magari anche nei commenti di questo post: come cavolo faccio a comunicargli le mie domande? :D

function f_full_feed() {
  global $more;
  if( is_feed() )
    $more = true;
}

add_action('parse_query', 'f_full_feed');

Esistono ben altri due plugin che fanno la stessa cosa, ne hanno parlato Andrea Beggi e Italia SW, sono anche questi molto semplici, ma vi suggerisco di usare il mio :D

Non cambia molto, ma la “concorrenza” filtra il contenuto del post: sovrascrive il post spezzato con il post completo ed elimina il tag more dal post. La mia versione si limita a settare il valore di una variabile globale a true, cambiando cosÃ?¬ il comportamento della funzione the_content() di WordPress che stampa il contenuto.

In sostanza il mio codice esegue una semplice operazione e la esegue una sola volta, gli altri due plugin eseguono alcune semplici operazione e le eseguono per ogni post. I benefici che ne trarrete non vi cambieranno praticamente niente :D

Per proteggersi dallo spam usa un semplice, ma, almeno per ora, efficace metodo: se non sei uno spambot devi scrivere “limone” in un text box :D

Dato che la parola è sempre quella e dato che il nick che uso per commentare pure, mi sono fatto un mini user script per Greasemonkey (che è una estensione per Firefox) per compilare in automatico quel form. Quindi se mi trovo nella pagina di un post del blog di Antirez, l’userscript inserisce al posto mio “Fra_T” nel campo “Nome” e “limone” in quello dell’antispam (eh sÃ?¬, è brutto non sapere cosa fare! :)

Se qualcuno usa l’estensione Greasemonkey, legge il blog di Antirez ed è abbastanza pigro da voler installare questo userscript, eccolo: antirez.user.js.

Lo script è da personalizzare sostituendo “Fra_T” con il nome preferito per commentare.

Su Greasemonkey:

• Greasespot.net, la homepage dell’estensione Greasemonkey.
• Dive Into Greasemonkey, un libro, consultabile gratuitamente online, about programming with Greasemonkey.
• Userscripts.org, un mega contenitore di user script.

• Documentazione per gli Sviluppatori in Italiano.
• Developer Documentation #Plugin Development in Inglese.
• Anatomia di un plugin per WordPress, un esempio, passo a passo, della creazione di un plugin.

Pseudo Type Callback

Alcune funzioni di PHP accettano come argomento il callback di una funzione.

Il callback (richiamo) di una funzione, che puÃ?² essere una stringa (per semplici funzioni) o un array (per metodi di oggetti o di classi), è usato appunto per richiamare la funzione a cui si riferisce. Potete far riferimento al manuale PHP per approfondire l’argomento: pseudo type callback.

call_user_func_array

Una funzione che accetta come argomento un callback è, tra le altre, la funzione call_user_func_array. Prendiamo come esempio la seguente funzione somma, il cui callback è la stringa “somma”, ovvero il suo nome:

function somma($a, $b){
   echo $a + $b;
}

Con call_user_func_array( 'somma', array(7, 9) ) otteniamo lo stesso output che otterremmo con somma(7, 9), cioè 16.

In effetti scrivere somma(7, 9) è decisamente più elegante che scrivere call_user_func_array( 'somma', array(7, 9) ), ma in certi contesti l’uso di questa funzione potrebbe essere utile, credo.

Ad esempio possiamo immaginare che in una parte di un programma (un plugin) decidiamo quali funzioni eseguire ed in quale punto, cos�¬ che nel cuore del programma quelle funzioni siano eseguite. Ma mantenendo i plugin ed il programma principale separati.

L’architettura a plugin di WordPress è basta su questo sistema. Sparse un po’ ovunque ci sono funzioni che eseguono callback.

Hello World.

Semplificando leggermente, immaginiamo che questo sia il codice sorgente di WordPress:

$string = 'Hello World !!'
$string = apply_filters('hello', $string);

La funzione apply_filters non fa altro che eseguire le funzioni agganciate al tag hello, passandogli come argomento $string, e ritornando il valore di $string eventualmente modificato.

CosÃ?¬, se vogliamo modificare $string, basta definire una funzione ed agganciarla al tag hello:

function hello_fra($string){
   return str_replace('World', 'Fra', $string);
}

add_filter('hello', 'hello_fra')

Ok, forse abbiamo semplificato troppo, ma il principio è questo :)

add_filter, add_action e $wp_filter.

Tutti gli agganci tra tag e callback sono gestiti tramite l’array multidimensionale $wp_filter. Se non altro per curiositÃ? , potete scrivere in un plugin print_r($wp_filter), tanto per sapere di cosa stiamo parlando :)

Per aggiungere un item a $wp_filter si puÃ?² usare la funzione add_filter o il suo alias add_action:

add_filter('tag', 'callback', 'priorit� ', 'argomenti passati nel callback')

Gli argomenti tag e callback li abbiamo giÃ?  visti, la prioritÃ?  è opzionale, di default è 10, indica con quale prioritÃ?  deve essere eseguito il callback (ad esempio una funzione che permette di eseguire il codice PHP in un post, dovrebbe essere eseguita prima di quella che si occupa della formattazione).

Il numero di argomenti accettati nel callback, anche questo opzionale, di default è 1: indica quanti argomenti passare alla funzione richiamata. Se nel codice di WordPress trovassimo un:

$something = appy_filters('wp_tag', $something, $someother);

Per poter utilizzare la variabile $someother in una funzione, dovremmo specificare che gli argomenti aspettati sono 2 e non 1, quindi:

add_filter('wp_tag', 'valid_callback', 10, 2);

La funzione appy_filters non ha un numero massimo di argomenti (in teoria): prende tutti gli argomenti passati e valuta quanti passarne ad ogni funzione agganciata al tag specificato.

A caccia di Hooks.

Oltre a sbirciare il codice di altri plugin o conoscere a memoria tutti gli agganci di WordPress (improbabile) e non tutti documentati, avete un’altra via per capire quale hook usare per… “fare qualcosa”: cercare direttamente nel codice sorgente i richiami a tre funzioni:

1. apply_filters('aggancio', $var[, $var,...])
2. do_action('aggancio'[, $var, $var,...])
3. do_action_ref_array('aggancio', array)

Quando vedete una di queste tre funzioni, significa che in quel punto potete agganciare una qualche funzione con le stesse modalit�  sopra descritte.

Filtri e azioni.

La prima (apply_filters), come abbiamo visto, permette di filtrare il valore di una variabile eseguendo i callback agganciati ad un tag.

La seconda e la terza (do_action e do_action_ref_array) sono molto simili alla prima, ma non servono per filtrare, servono invece per creare un’azione. In pratica la differenza è che la prima ritorna un risultato, la seconda e la terza no.

Quindi probabilmente, nel codice sorgente di WordPress, troveremo qualcosa di simile per un filtro:

$var = apply_filters('filtro', $var);

Mentre per una azione direttamente:

do_action('azione');

Per lo stesso principio, generalmente, una funzione agganciata ad un filtro dovrÃ?  ritornare un risultato, mentre una funzione agganciata ad un’azione dovrÃ?  produrre output.

Rendere disponibili API.

Naturalmente creare nuovi tag a cui agganciare funzioni non è prerogativa unica di WordPress e, anzi, nel caso di plugin complicati, sarebbe opportuno mettere a disposizione API per il plugin stesso. Ad esempio, per permettere di filtrare una variabile di un plugin, basta:

// Codice del mio complicatissimo plugin
$var = apply_filters('fra_t_complicato_plugin_filtri_per_var', $var)

E cosÃ?¬ facendo ogni altro plugin, utilizzando il tag “fra_t_complicato_plugin_filtri_per_var”, potrÃ?  modificare il valore di $var del mio plugin.

Il tag speciale ‘all’.

Se volessimo agganciare un callback a tutti i filtri e le azioni, potremmo usare il tag “all”.

Non mi viene in mente niente di particolarmente utile da farci, ma ad esempio, con un plugin come il seguente, possiamo ottenere alcune statistiche su i vari agganci richiamati nelle diverse parti del codice:

// Aggancio la funzione che conter�  il numero di tag chiamati.
add_filter('all', 'count_tags_called');

function count_tags_called($arg, $return_counter = false){
	static $a = 0;

	if($return_counter) return $a;

	$a++;
	return $arg;
}

// Ritorna il numero di tag chiamati
function tags_called(){
	return count_tags_called('', true);
}
function num_actions(){
	global $wp_actions;
	return count($wp_actions);
}
// Quanti dei tag chiamati sono usati come filtro (totale - numero di azioni)
function num_filters(){
	return tags_called() - num_actions();
}

// Stampa statistiche sull'uso di filtri e azioni
function api_stats(){
	_e('Here we have '.tags_called().' hooks: '.num_filters().' filters and '.num_actions().' actions');
}

Con api_stats() sapremo quante volte è stata utilizzata una delle tre funzioni apply_filters, do_action o do_action_ref_array. Il totale è diviso in filtri ed in azioni. L’output sarebbe qualcosa de genere: Here we have 1168 hooks: 1152 filters and 16 actions.

Questo codice è da usare solo a scopo di test, in quanto usare il tag ‘all’ attualmente “sballa” tutte le prioritÃ?  in $wp_filter ed alcuni plugin potrebbero non funzionare correttamente.

Altre funzioni

Altre funzioni utili sono:

• remove_filter e l’alias remove_action, permettono di rimuovere filtri ed azioni. Accettano gli stessi argomenti di add_action e add_filter.
• register_activation_hook e register_deactivation_hook, permettono di eseguire una funzione all’attivazione ed alla disattivazione di un plugin. Si usano cosÃ?¬:

  function alla_attivazione(){
     return;
  }
  register_activation_hook(__file__, 'alla_attivazione');

Approfondimenti.

Le funzioni trattate in questo post sono prese dal file di WordPress (ad oggi, la versione 2.1) wp-includes/plugin.php. Per approfondire potete far riferimento a quello.

GT Post approval aggiunge un pulsante approva/rifiuta a fianco di ogni post nella pagina edit > post del pannello di amministrazione di WordPress.

Un post approvato è visibile in ogni sezione di WordPress, mentre uno rifiutato è visibile solo nell’archivio dell’autore.

In pratica si ottiene la Massima partecipazione senza che le linee editoriali siano comprese e condivise da tutti :D

• Scarica il plugin.
• Sorgente.

Installazione.

Come tutti i plugin: download, decomprimere e piazzare nella cartella wp-content/plugins. Pannello di amministrazione > Plugin > Cercare la riga GT Post approval e cliccare attiva.

All’installazione tutti i post giÃ?  pubblicati vengono approvati, mentre i successivi post dovranno essere approvati manualmente da un editore o un amministratore.

Difetti.

Il plugin ha il difetto che non si integra con le funzioni per stampare categorie o archivi temporali. Per fare un esempio, se l’unico post di gennaio è un post non approvato, il link “gennaio” apparirÃ?  ma non conterrÃ?  nessun post.

Perch�© GT?!

“GT” perchÃ?© è scritto per il blog GT Globalwarming Awareness2007, che è il blog degli utenti del forum di Giorgiotave che partecipano al SEO World Championship.

Tecnicismi.

Il plugin usa le API della classe WP_Query per modificare il loop di WordPress e per prendere informazioni sui post correnti. La API per eseguire funzioni all’attivazione di un determinato plugin e alcune API per modificare l’area di amministrazione. Sbircia il codice commentato in italiano o in inglese, se ti interessa.

Preso dalle FAQ su WP MU:

La pronuncia popolare è scandire le lettere separatamente, WordPress em-iu. L’intenzione originale era usare il simbolo µ da pronunciare miu. Ma se vi sentite abbastanza bovini potete anche dire “WordPress Muuuuu” :D

Installazione di WordPress MU.

Ho scaricato WP MU 1.0, è ho caricato i file nella cartella mu del mio server locale. Poi ho creato un host virtuale modificando il file httpd.conf di Apache e il file host di Windows per collegare un dominio a localhost/mu (una cosa interessantissima: mio padre una volta si è preso un virus sul PC che, proprio modificando il file host di Windows, impediva di fare gli aggiornamenti delle definizioni coi principali anti-virus).

Mi sono collegato a localhost.wpmu (l’host che con molta fantasia ho scelto nello step precedente), ho seguito la procedura di installazione e tutto è andato bene.

Installare i plugin in WordPressMU.

In WPMU ci sono 2 modi per installare plugin, uno è caricarli nella cartella wp-content/mu-plugins, in questo caso non c’è bisogno di attivarli, ed i plugin valgono per tutti i blog.

Il secondo modo per installare i plugin è come quello della versione di WordPress… ehm… “normale”, ovvero caricarli nella cartella wp-content/plugins, in questo caso ogni blog deve attivarli. Di default i singoli blog NON possono attivare plugin, si possono abilitare a farlo delle opzioni di amministrazione.

Installare il Widgets Plugin.

Installare il plugin per i Widgets è semplicissimo, davvero! Solo che ci ho perso 4 ore. Ho seguito le istruzioni di Jason, quelle di Codex, ho letto qualche discussione nel forum di supporto, e anche se Drmike si è arrabbiato, io non ci riuscivo ad installare ’sto plugin.

Insomma, il plugin c’era. I temi erano giÃ?  Widgetizzati, ma il menu per selezionare i Widgets non mi voleva apparire.

Dopo vari tentativi e ricerche, ho notato che con la distribuzione del plugin per i Widgets c’erano anche i file functions.php e sidebar.php dei due temi base di WordPress: Kubrick e Classic. Ho provato a sostituirli agli originali e… per magia il menu per selezionare i Widgets è apparso.

Guardando con più attenzione, i temi non erano giÃ?  Widgetizzati come credevo, ma erano mezzi Widgetizzati! Cioè, la sidebar era Widgetizzata (è questo che mi ha fregato), ma il file functions.php no!

Va be’, tutto e bene quel che finisce bene, spero che questo post faccia risparmiare tempo a qualcuno. In compenso ho provato ad installare Wordpress MU su Terenzani.it, ma non c’è stata storia. Forse è in conflitto con WordPress normale che è installato nella root e col fatto che ad installarlo nell’unico database che ho a disposizione, una tabella la hanno in comune. Non so…

Ah, nelle mie disperate ricerche ho trovato alcune risorse interessanti su WordPress Muuuuu:

• WordPress MU Plugins, un blog dedicato ai plugin per WP MU.
• La pagina di WordPress MU su Codex, raccoglie molti link ed informazioni utili.
• Il Wiki di WordPress MU, che, credo, diventerÃ?  l’equivalente di Codex per WordPress.
• WPMUDEV.org, ad oggi è ancora in allestimento, ma ha giÃ?  un sacco di risorse utili (plugin, temi, patch, news…).

(La mucca con gli occhiali è presa da http://www.corvitto.com).

Il manuale di GA propone infatti, per monitore click su link la cui destinazione non puÃ?² contenere lo script di monitoraggio, di inserire un onclick = urchinTracker('/directory/che figurer�  nelle statistiche.htm').

La libreria GA-urchin.trackLinks.js evita di modificare ogni link esterno o di download.

1. Download GA-urchin.trackLinks.js
2. Demo online

Come si usa?

La sintassi minima per tracciare i link esterni è:

urchin = new urchin();
urchin.trackLinks();

Per tracciare anche i download:

urchin = new urchin();
urchin.trackDownload = "zip|rar|phps|avi|pdf";
urchin.trackLinks();

In questo esempio lo script traccer� , oltre ai link esterni, i click a risorse interne con estensione zip, rar, phps, avi o pdf.

Dove inserire il codice? Ci sono 2 possibilit�  + 1:

1. Se il vostro codice di Google Analytics è posto prima della chiusura del tag body, come indicato dalle linee guida di GA, dovete modificare:

   ...
   <script src="http://www.google-analytics.com/urchin.js" type="text/javascript"></script>
   <script type="text/javascript">
   _uacct = "UA-XXXXXX-X";
   urchinTracker();
   </script>
   </body>

   e farlo diventare:

   ...
   <script src="http://www.google-analytics.com/urchin.js" type="text/javascript"></script>
   <script src="/path/GA.urchin.trackLinks.js" type="text/javascript"></script>
   <script type="text/javascript">
   urchin = new urchin();
   urchin.trackDownload = "zip|rar|phps|avi";
   urchin.trackLinks();
   _uacct = "UA-XXXXXX-X";
   urchinTracker();
   </script>
   </body>

2. Se, invece, volete mettere lo script nell’head, il codice della libreria deve essere azionato all’evento onload:

   ...
   <script src="http://www.google-analytics.com/urchin.js" type="text/javascript"></script>
   <script src="/path/GA.urchin.trackLinks.js" type="text/javascript"></script>
   <script type="text/javascript">
   window.onload=function(){
     urchin = new urchin();
     urchin.trackDownload = "zip|rar|phps|avi";
     urchin.trackLinks();
   }
   _uacct = "UA-XXXXXX-X";
   urchinTracker();
   </script>
   </head>

   O, per non rischiare di perdere click, utilizzare un’apposita libreria, come quella di Andrea Giammarchi (meno di 1 Kb), ed il codice:

   ...
   <script src="http://www.google-analytics.com/urchin.js" type="text/javascript"></script>
   <script src="/path/GA.urchin.trackLinks.js" type="text/javascript"></script>
   <script src="/path/onContent.js" type="text/javascript"></script>
   <script type="text/javascript">
   onContent(function(){
     urchin = new urchin();
     urchin.trackDownload = "zip|rar|phps|avi";
     urchin.trackLinks();
   });
   _uacct = "UA-XXXXXX-X";
   urchinTracker();
   </script>
   </head>

   Se decidete di mettere il codice nell’head questa seconda soluzione è la più indicata.

3. Se invece utilizzate WordPress, potete utilizzare il plugin Google Analyticator di Ronald Heft che utilizza proprio queste due librerie Javascript e permette di personalizzare il codice direttamente dal pannello di amministrazione di WordPress.

La procedura dello script.

Questi sono, a grandi linee, gli step dello script al lancio della funzione trackLinks():

1. Ricava il dominio corrente (es. www.terenzani.it).
2. Verifica ogni link del documento.
3. Solo se il link è interno:
   1. Controlla l’estensione
   2. Se l’estensione è tra quelle impostate tra i file da considerare scaricabili, setta a quel link, per l’evento onclick, il lancio della funzione urchinTracker('/download/destinazione--a--cui--punta--il--link').
4. Se non è un link interno, setta per l’evento onclick il lancio della funzione urchinTracker('/outgoing/destinazione--a--cui--punta--il--link').

Il codice commentato.

Metto le mani avanti: non ho molta esperienza con Javascript, quindi è possibile che abbia usato qualche metodo bislacco. Comunque ogni consiglio è ben accetto.

GA urchin.trackLinks 0.1:

function urchin(){

 // La variabile in cui settare le estensioni da considerare download separate da |
 this.trackDownload = '';

 this.trackLinks = function(){
  var a = document.getElementsByTagName('a');
  // Estrae dalla location attuale il dominio
  // In domain[0] è salvato http://dominio.it/ o https://dominio.it/
  // In domain[2] dominio.it
  var domain = /^(http|https):\\/\\/([a-z-.0-9]+)[\\/]{0,1}/i.exec(window.location);
  // Le espressioni per individuare link interni e download
  var internalLink = new RegExp("^(http|https):\\/\\/"+domain[2], "i");
  var isDownload = new RegExp("("+this.trackDownload+")$", "i");

  // Per ogni link...
  for(var i = 0; i < a.length; i++){
   // Se è interno...
   if(internalLink.test(a[i].href)){
    // ... e se ha l'estensione definita in this.trackDownload ...
    if(this.trackDownload && isDownload.test(a[i].href))
     a[i].onclick = function(){
      // Pulisce e traccia l'URL
      urchinTracker('/download/'+this.href.replace(/^(http|https):\\/\\/([a-z-.0-9]+)\\//i, '').split('/').join('--'));
     }
   }
   else
   // è esterno
    a[i].onclick = function(){
     // Pulisce e traccia l'URL
     urchinTracker('/outgoing/'+this.href.replace(/^http:\\/\\/|https:\\/\\//i, '').split('/').join('--'));
    }
  }
 }
} 

Compatibilit�  browser.

La libreria è stata testata con IE (5, 5.5 e 7) FireFox 2.0 e Opera 9.0 per Windows. Se avete un altro browser potete provare la demo on line.

Change logs.

Version 0.2: corrected the regexp to detect downloads: "("+this.trackDownload+")$".

<?php
// Include nel tema il file wp-includes/rss-functions.php
  require_once(ABSPATH . WPINC . "/rss-functions.php");

// Inizializza la classe e prende il feed RSS
  $feedRSS = @fetch_rss("http://del.icio.us/rss/lit");

// Verifica che ci siano item nel feed RSS
  if(isset($feedRSS->items) && 0 != count($feedRSS->items)){
?>

// Crea un elenco puntato con gli item del feed RSS
<ul>
  <?php
    foreach($feedRSS->items as $k => $tag){
// Limita il numero di item da mostrare a 7.
      if($k==7) break;
      echo "<li><a href='$tag[link]'>$tag[title]</a></li>";
      if($tag['description']) echo " - $tag[description]</li>";
      else echo "</li>";
    }
  }
  ?>
</ul>

MagpieRSS prevede anche un sistema di caching che di default è attivo. Quindi lo script non prende il feed ogni volta che una pagina viene visualizzata, ma allo scadere della cache, che di default dura 1 ora.

Se vogliamo aumentare la durata della cache, dobbiamo definire la constante MAGPIE_CACHE_AGE con la durata in secondi della cache, prima del richiamo al metodo fetch_rss():

// require_once(ABSPATH . WPINC . "/rss-functions.php");

// La cache durer�  un giorno (24 ore * 60 minuti * 60 secondi = 86400)
define('MAGPIE_CACHE_AGE', 86400);

// $rss = @fetch_rss("http://del.icio.us/rss/lit");
// ecc...

Se poi volte sapere quali dati potete ricavare da un feed un semplice metodo è l’uso della funzione print_r() di PHP:

<pre>
<?php
// Include nel tema il file wp-includes/rss-functions.php
  require_once (ABSPATH . WPINC . "/rss-functions.php");

// Inizializza la classe e prende il feed RSS
  $feedRSS = @fetch_rss("http://del.icio.us/rss/lit");

// Le informazioni sul feed:
  print_r($feedRSS->channel);

// Gli elementi degli items:
  print_r($feedRSS->items);

?></pre>

Se non utilizzate WordPress la procedura non è molto diversa, ci ha scritto un tutorial Simone Carletti: Semplice parser in PHP.

Buon divertimento con le vostre sidebar! :)